@prompd/cli 0.4.4 → 0.4.6

package/dist/lib/workflowExecutor.js

@@ -1239,6 +1239,103 @@ async function executePromptNode(node, context, options, trace, state, workflowF
         },
     };
     await emitAgentCheckpoint(afterEvent, options, workflowFile);
+    // Apply guardrail validation if configured
+    if (data.guardrail) {
+        const guardrail = data.guardrail;
+        let isRejected = false;
+        // Evaluate rejection condition
+        if (guardrail.rejectionExpression) {
+            // Advanced: Custom rejection expression
+            try {
+                // Extend context with response in nodeOutputs for guardrail expression evaluation
+                const guardContext = {
+                    nodeOutputs: { ...context.nodeOutputs, response: result },
+                    variables: context.variables,
+                    workflow: context.workflow,
+                    previous_output: context.previous_output,
+                };
+                const evalResult = evaluateExpression(guardrail.rejectionExpression, guardContext);
+                isRejected = Boolean(evalResult);
+            }
+            catch (error) {
+                addTraceEntry(trace, {
+                    type: 'debug_step',
+                    nodeId: node.id,
+                    nodeName: data.label,
+                    message: `Guardrail expression evaluation failed: ${error instanceof Error ? error.message : String(error)}`,
+                }, options);
+                isRejected = false; // Default to not rejected on expression error
+            }
+        }
+        else if (guardrail.rejectionField && guardrail.expectedFormat === 'json') {
+            // Simple: Field-based check for JSON responses
+            try {
+                const parsed = typeof result === 'string' ? JSON.parse(result) : result;
+                const fieldValue = parsed?.[guardrail.rejectionField];
+                if (guardrail.passWhen === 'true') {
+                    // Pass when field is true, reject when false
+                    isRejected = !fieldValue;
+                }
+                else if (guardrail.passWhen === 'false') {
+                    // Pass when field is false, reject when true
+                    isRejected = Boolean(fieldValue);
+                }
+                addTraceEntry(trace, {
+                    type: 'debug_step',
+                    nodeId: node.id,
+                    nodeName: data.label,
+                    message: `Guardrail field check: ${guardrail.rejectionField}=${fieldValue}, passWhen=${guardrail.passWhen}, rejected=${isRejected}`,
+                }, options);
+            }
+            catch (error) {
+                addTraceEntry(trace, {
+                    type: 'debug_step',
+                    nodeId: node.id,
+                    nodeName: data.label,
+                    message: `Guardrail JSON parse failed: ${error instanceof Error ? error.message : String(error)}`,
+                }, options);
+                isRejected = false; // Default to not rejected on parse error
+            }
+        }
+        // Handle rejection
+        if (isRejected) {
+            const failAction = guardrail.failAction || 'error';
+            const rejectMessage = guardrail.customRejectMessage || 'Content rejected by guardrail';
+            addTraceEntry(trace, {
+                type: 'debug_step',
+                nodeId: node.id,
+                nodeName: data.label,
+                message: `Guardrail REJECTED content, failAction=${failAction}`,
+                data: { rejectMessage, result },
+            }, options);
+            if (failAction === 'error' || failAction === 'stop') {
+                throw new Error(rejectMessage);
+            }
+            else if (failAction === 'continue') {
+                // Return reject message and continue workflow
+                return rejectMessage;
+            }
+        }
+        else {
+            // Guardrail passed - determine output based on outputMode
+            const outputMode = guardrail.outputMode || 'passthrough';
+            addTraceEntry(trace, {
+                type: 'debug_step',
+                nodeId: node.id,
+                nodeName: data.label,
+                message: `Guardrail PASSED content, outputMode=${outputMode}`,
+            }, options);
+            if (outputMode === 'original') {
+                // Return the original input that was sent to the guardrail prompt
+                result = context.previous_output;
+            }
+            else if (outputMode === 'reject-message') {
+                // Return custom message even on pass (useful for custom routing)
+                result = guardrail.customRejectMessage || result;
+            }
+            // 'passthrough' - keep result as-is (default)
+        }
+    }
     // Apply output mapping if defined
     if (data.outputMapping) {
         const mapped = {};
@@ -3863,8 +3960,36 @@ Analyze the input above. Return a JSON object:
             if (jsonMatch) {
                 try {
                     const parsed = JSON.parse(jsonMatch[1] || jsonMatch[0]);
-                    // If guardrailPassExpression is configured, use it to evaluate the result
-                    if (data.guardrailPassExpression) {
+                    // Priority 1: Custom rejection expression (new field)
+                    if (data.guardrailRejectionExpression) {
+                        const exprContext = { ...context, response: parsed, previous_output: parsed, input: parsed };
+                        const exprResult = evaluateExpression(data.guardrailRejectionExpression, exprContext);
+                        guardrailResult = {
+                            rejected: Boolean(exprResult), // Expression returns true for REJECT
+                            score: typeof parsed.score === 'number' ? parsed.score : undefined,
+                            analysis: parsed.analysis,
+                        };
+                    }
+                    // Priority 2: Field-based check (new fields)
+                    else if (data.guardrailRejectionField && data.guardrailExpectedFormat === 'json') {
+                        const fieldValue = parsed?.[data.guardrailRejectionField];
+                        if (data.guardrailPassWhen === 'true') {
+                            // Pass when field is true, reject when false
+                            guardrailResult.rejected = !fieldValue;
+                        }
+                        else if (data.guardrailPassWhen === 'false') {
+                            // Pass when field is false, reject when true
+                            guardrailResult.rejected = Boolean(fieldValue);
+                        }
+                        else {
+                            // Default: check parsed.rejected field
+                            guardrailResult.rejected = parsed.rejected === true;
+                        }
+                        guardrailResult.score = typeof parsed.score === 'number' ? parsed.score : undefined;
+                        guardrailResult.analysis = parsed.analysis;
+                    }
+                    // Priority 3: Legacy passExpression
+                    else if (data.guardrailPassExpression) {
                         const exprContext = { ...context, previous_output: parsed, input: parsed };
                         const exprResult = evaluateExpression(data.guardrailPassExpression, exprContext);
                         guardrailResult = {
@@ -3873,8 +3998,8 @@ Analyze the input above. Return a JSON object:
                             analysis: parsed.analysis,
                         };
                     }
+                    // Priority 4: Fallback to checking parsed.rejected field
                     else {
-                        // Fallback to checking parsed.rejected field
                         guardrailResult = {
                             rejected: parsed.rejected === true,
                             score: typeof parsed.score === 'number' ? parsed.score : undefined,
@@ -3884,16 +4009,22 @@ Analyze the input above. Return a JSON object:
                 }
                 catch {
                     // If JSON parsing fails, try expression evaluation with raw response
-                    if (data.guardrailPassExpression) {
+                    if (data.guardrailRejectionExpression) {
+                        const exprContext = { ...context, response: responseStr, guardrail_response: responseStr };
+                        const exprResult = evaluateExpression(data.guardrailRejectionExpression, exprContext);
+                        guardrailResult.rejected = Boolean(exprResult);
+                    }
+                    else if (data.guardrailPassExpression) {
                         const exprContext = { ...context, guardrail_response: responseStr };
                         const exprResult = evaluateExpression(data.guardrailPassExpression, exprContext);
                         guardrailResult.rejected = !exprResult;
                     }
                 }
             }
-            // Apply score threshold ONLY if no passExpression is configured
-            // This ensures passExpression takes precedence when both are set
-            if (!data.guardrailPassExpression && data.guardrailScoreThreshold !== undefined && guardrailResult.score !== undefined) {
+            // Apply score threshold ONLY if no passExpression/rejectionExpression/fieldCheck is configured
+            // This ensures explicit conditions take precedence
+            if (!data.guardrailRejectionExpression && !data.guardrailPassExpression && !data.guardrailRejectionField &&
+                data.guardrailScoreThreshold !== undefined && guardrailResult.score !== undefined) {
                 guardrailResult.rejected = guardrailResult.score < data.guardrailScoreThreshold;
             }
             // Emit afterGuardrail checkpoint
@@ -3905,26 +4036,54 @@ Analyze the input above. Return a JSON object:
                 return { cancelled: true, stage: 'afterGuardrail', guardrailResult };
             }
             if (guardrailResult.rejected) {
+                const failAction = data.guardrailFailAction || 'error';
+                const rejectMessage = data.guardrailCustomRejectMessage || 'Input rejected by guardrail';
                 addTraceEntry(trace, {
                     type: 'debug_step',
                     nodeId: node.id,
                     nodeName: data.label,
-                    message: 'Guardrail rejected input',
-                    data: { guardrailResult },
+                    message: `Guardrail rejected input, failAction=${failAction}`,
+                    data: { guardrailResult, rejectMessage },
                 }, options);
-                return {
-                    rejected: true,
-                    guardrailResult,
-                    input: currentInput,
-                };
+                if (failAction === 'error' || failAction === 'stop') {
+                    // Return rejection result for branching (original behavior)
+                    return {
+                        rejected: true,
+                        guardrailResult,
+                        input: currentInput,
+                    };
+                }
+                else if (failAction === 'continue') {
+                    // Continue with reject message as the input
+                    currentInput = rejectMessage;
+                    addTraceEntry(trace, {
+                        type: 'debug_step',
+                        nodeId: node.id,
+                        nodeName: data.label,
+                        message: 'Continuing with reject message as input',
+                    }, options);
+                }
+            }
+            else {
+                // Guardrail passed - handle outputMode
+                const outputMode = data.guardrailOutputMode || 'passthrough';
+                addTraceEntry(trace, {
+                    type: 'debug_step',
+                    nodeId: node.id,
+                    nodeName: data.label,
+                    message: `Guardrail passed, outputMode=${outputMode}`,
+                    data: { score: guardrailResult.score },
+                }, options);
+                if (outputMode === 'original') {
+                    // Keep currentInput as-is (original input that was validated)
+                    // No change needed
+                }
+                else if (outputMode === 'reject-message') {
+                    // Use custom message even on pass
+                    currentInput = data.guardrailCustomRejectMessage || currentInput;
+                }
+                // 'passthrough' - keep currentInput as-is (default)
             }
-            addTraceEntry(trace, {
-                type: 'debug_step',
-                nodeId: node.id,
-                nodeName: data.label,
-                message: 'Guardrail passed',
-                data: { score: guardrailResult.score },
-            }, options);
         }
         catch (error) {
             addTraceEntry(trace, {