@exaudeus/workrail 0.12.0 → 0.14.0

package/dist/application/services/enhanced-loop-validator.js

@@ -102,10 +102,10 @@ let EnhancedLoopValidator = class EnhancedLoopValidator {
     }
     getKnownLoopVariables(loopStep) {
         const vars = new Set();
-        vars.add(loopStep.loop.iterationVar || 'iteration');
+        vars.add(loopStep.loop.iterationVar || 'currentIteration');
         if (loopStep.loop.type === 'forEach') {
-            vars.add(loopStep.loop.itemVar || 'item');
-            vars.add(loopStep.loop.indexVar || 'index');
+            vars.add(loopStep.loop.itemVar || 'currentItem');
+            vars.add(loopStep.loop.indexVar || 'currentIndex');
         }
         vars.add('context');
         vars.add('workflowId');

package/dist/application/services/step-output-decoder.d.ts

@@ -0,0 +1,6 @@
+export interface SchemaDecodeResult {
+    readonly value: unknown;
+    readonly warnings: readonly string[];
+}
+export declare function decodeForSchemaValidation(output: string, schema: unknown): SchemaDecodeResult | null;
+export declare function schemaExpectsObjectOrArray(schema: unknown): boolean;

package/dist/application/services/step-output-decoder.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeForSchemaValidation = decodeForSchemaValidation;
+exports.schemaExpectsObjectOrArray = schemaExpectsObjectOrArray;
+const COERCION_WARNING = 'Coerced double-encoded JSON (JSON string containing JSON) into an object/array for schema validation.';
+function decodeForSchemaValidation(output, schema) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed === 'string' && schemaExpectsObjectOrArray(schema)) {
+        const inner = parsed.trim();
+        if (inner.startsWith('{') || inner.startsWith('[')) {
+            try {
+                const innerParsed = JSON.parse(inner);
+                if (innerParsed !== null && typeof innerParsed === 'object') {
+                    return { value: innerParsed, warnings: [COERCION_WARNING] };
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return { value: parsed, warnings: [] };
+}
+function schemaExpectsObjectOrArray(schema) {
+    if (schema == null || typeof schema !== 'object')
+        return false;
+    const s = schema;
+    const t = s.type;
+    if (t === 'object' || t === 'array')
+        return true;
+    if (Array.isArray(t) && (t.includes('object') || t.includes('array')))
+        return true;
+    if (s.properties && typeof s.properties === 'object')
+        return true;
+    if (Array.isArray(s.required) && s.required.length > 0)
+        return true;
+    const combos = ['oneOf', 'anyOf', 'allOf'];
+    for (const k of combos) {
+        if (Array.isArray(s[k]) && s[k].some((child) => schemaExpectsObjectOrArray(child))) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/application/services/validation-engine.d.ts

@@ -7,6 +7,9 @@ export declare class ValidationEngine {
     private ajv;
     private schemaCache;
     private enhancedLoopValidator;
+    private static readonly DEFAULT_FAILURE_SUGGESTION;
+    private static readonly JSON_OBJECT_NOT_STRING_SUGGESTION;
+    private static readonly JSON_STRING_CONTAINS_JSON_SUGGESTION;
     constructor(enhancedLoopValidator: EnhancedLoopValidator);
     private compileSchema;
     private evaluateCriteria;
@@ -17,8 +20,14 @@ export declare class ValidationEngine {
     private isValidationComposition;
     validate(output: string, criteria: ValidationCriteria, context?: ConditionContext): Promise<ValidationResult>;
     private evaluateRule;
+    private looksLikeQuotedJsonSnippet;
+    private maybePushJsonObjectNotStringSuggestion;
+    private uniqueSuggestions;
+    private formatDefaultContainsMessage;
     validateLoopStep(step: LoopStepDefinition, workflow: Workflow): ValidationResult;
     validateWorkflow(workflow: Workflow): ValidationResult;
+    private collectQuotedJsonValidationMessageWarnings;
+    private collectValidationRuleMessages;
     private isValidVariableName;
     private validateStepFunctionCalls;
     private isArgTypeValid;

package/dist/application/services/validation-engine.js

@@ -14,6 +14,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var ValidationEngine_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidationEngine = void 0;
 const tsyringe_1 = require("tsyringe");
@@ -22,7 +23,8 @@ const condition_evaluator_1 = require("../../utils/condition-evaluator");
 const ajv_1 = __importDefault(require("ajv"));
 const workflow_definition_1 = require("../../types/workflow-definition");
 const enhanced_loop_validator_1 = require("./enhanced-loop-validator");
-let ValidationEngine = class ValidationEngine {
+const step_output_decoder_1 = require("./step-output-decoder");
+let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
     constructor(enhancedLoopValidator) {
         this.schemaCache = new Map();
         this.ajv = new ajv_1.default({ allErrors: true });
@@ -52,7 +54,8 @@ let ValidationEngine = class ValidationEngine {
                 return {
                     valid: compositionResult,
                     issues: compositionResult ? [] : ['Validation composition failed'],
-                    suggestions: compositionResult ? [] : ['Review validation criteria and adjust output accordingly.']
+                    suggestions: compositionResult ? [] : ['Review validation criteria and adjust output accordingly.'],
+                    warnings: undefined,
                 };
             }
             throw new error_handler_1.ValidationError('Invalid validation criteria format');
@@ -66,12 +69,14 @@ let ValidationEngine = class ValidationEngine {
     }
     evaluateRuleArray(output, rules, context) {
         const issues = [];
+        const suggestions = [];
+        const warnings = [];
         for (const rule of rules) {
             try {
                 if (rule.condition && !(0, condition_evaluator_1.evaluateCondition)(rule.condition, context)) {
                     continue;
                 }
-                this.evaluateRule(output, rule, issues);
+                this.evaluateRule(output, rule, issues, suggestions, warnings);
             }
             catch (error) {
                 if (error instanceof error_handler_1.ValidationError) {
@@ -83,7 +88,8 @@ let ValidationEngine = class ValidationEngine {
         return {
             valid: issues.length === 0,
             issues,
-            suggestions: issues.length > 0 ? ['Review validation criteria and adjust output accordingly.'] : []
+            suggestions: issues.length > 0 ? this.uniqueSuggestions([...suggestions, ValidationEngine_1.DEFAULT_FAILURE_SUGGESTION]) : [],
+            warnings: warnings.length > 0 ? this.uniqueSuggestions(warnings) : undefined,
         };
     }
     evaluateComposition(output, composition, context) {
@@ -104,7 +110,9 @@ let ValidationEngine = class ValidationEngine {
                 return true;
             }
             const issues = [];
-            this.evaluateRule(output, criteria, issues);
+            const suggestions = [];
+            const warnings = [];
+            this.evaluateRule(output, criteria, issues, suggestions, warnings);
             return issues.length === 0;
         }
         if (this.isValidationComposition(criteria)) {
@@ -133,18 +141,19 @@ let ValidationEngine = class ValidationEngine {
                 suggestions: issues.length > 0 ? ['Provide valid output content.'] : []
             };
         }
-        const isValid = this.evaluateCriteria(output, criteria, context || {});
-        if (!isValid.valid) {
-            issues.push(...isValid.issues);
+        const evaluation = this.evaluateCriteria(output, criteria, context || {});
+        if (!evaluation.valid) {
+            issues.push(...evaluation.issues);
         }
         const valid = issues.length === 0;
         return {
             valid,
             issues,
-            suggestions: valid ? [] : ['Review validation criteria and adjust output accordingly.']
+            suggestions: valid ? [] : this.uniqueSuggestions([...evaluation.suggestions, ValidationEngine_1.DEFAULT_FAILURE_SUGGESTION]),
+            warnings: evaluation.warnings,
         };
     }
-    evaluateRule(output, rule, issues) {
+    evaluateRule(output, rule, issues, suggestions, warnings) {
         if (typeof rule === 'string') {
             const re = new RegExp(rule);
             if (!re.test(output)) {
@@ -157,7 +166,10 @@ let ValidationEngine = class ValidationEngine {
                 case 'contains': {
                     const value = rule.value;
                     if (typeof value !== 'string' || !output.includes(value)) {
-                        issues.push(rule.message || `Output must include "${value}"`);
+                        issues.push(rule.message || this.formatDefaultContainsMessage(value));
+                        if (this.looksLikeQuotedJsonSnippet(rule.message)) {
+                            this.maybePushJsonObjectNotStringSuggestion(suggestions);
+                        }
                     }
                     break;
                 }
@@ -166,6 +178,9 @@ let ValidationEngine = class ValidationEngine {
                         const re = new RegExp(rule.pattern, rule.flags || undefined);
                         if (!re.test(output)) {
                             issues.push(rule.message || `Pattern mismatch: ${rule.pattern}`);
+                            if (this.looksLikeQuotedJsonSnippet(rule.message)) {
+                                this.maybePushJsonObjectNotStringSuggestion(suggestions);
+                            }
                         }
                     }
                     catch {
@@ -177,31 +192,50 @@ let ValidationEngine = class ValidationEngine {
                     const { min, max } = rule;
                     if (typeof min === 'number' && output.length < min) {
                         issues.push(rule.message || `Output shorter than minimum length ${min}`);
+                        if (this.looksLikeQuotedJsonSnippet(rule.message)) {
+                            this.maybePushJsonObjectNotStringSuggestion(suggestions);
+                        }
                     }
                     if (typeof max === 'number' && output.length > max) {
                         issues.push(rule.message || `Output exceeds maximum length ${max}`);
+                        if (this.looksLikeQuotedJsonSnippet(rule.message)) {
+                            this.maybePushJsonObjectNotStringSuggestion(suggestions);
+                        }
                     }
                     break;
                 }
                 case 'schema': {
                     if (!rule.schema) {
                         issues.push(rule.message || 'Schema validation rule requires a schema property');
+                        if (this.looksLikeQuotedJsonSnippet(rule.message)) {
+                            this.maybePushJsonObjectNotStringSuggestion(suggestions);
+                        }
                         break;
                     }
                     try {
-                        let parsedOutput;
-                        try {
-                            parsedOutput = JSON.parse(output);
-                        }
-                        catch (parseError) {
+                        const decoded = (0, step_output_decoder_1.decodeForSchemaValidation)(output, rule.schema);
+                        if (!decoded) {
                             issues.push(rule.message || 'Output is not valid JSON for schema validation');
+                            if (this.looksLikeQuotedJsonSnippet(rule.message)) {
+                                this.maybePushJsonObjectNotStringSuggestion(suggestions);
+                            }
                             break;
                         }
+                        if (decoded.warnings.length > 0) {
+                            warnings.push(...decoded.warnings);
+                            this.maybePushJsonObjectNotStringSuggestion(suggestions);
+                            if (!suggestions.includes(ValidationEngine_1.JSON_STRING_CONTAINS_JSON_SUGGESTION)) {
+                                suggestions.push(ValidationEngine_1.JSON_STRING_CONTAINS_JSON_SUGGESTION);
+                            }
+                        }
                         const validate = this.compileSchema(rule.schema);
-                        const isValid = validate(parsedOutput);
+                        const isValid = validate(decoded.value);
                         if (!isValid) {
                             const errorMessages = validate.errors?.map((error) => `Validation Error at '${error.instancePath}': ${error.message}`) || ['Schema validation failed'];
                             issues.push(rule.message || errorMessages.join('; '));
+                            if (this.looksLikeQuotedJsonSnippet(rule.message)) {
+                                this.maybePushJsonObjectNotStringSuggestion(suggestions);
+                            }
                         }
                     }
                     catch (error) {
@@ -219,6 +253,50 @@ let ValidationEngine = class ValidationEngine {
         }
         throw new error_handler_1.ValidationError('Invalid validationCriteria format.');
     }
+    looksLikeQuotedJsonSnippet(message) {
+        if (typeof message !== 'string')
+            return false;
+        const m = message.trim();
+        if (m.length === 0)
+            return false;
+        if (m.includes('\\"{') || m.includes('\\"['))
+            return true;
+        if (m.includes('"{') || m.includes("'{") || m.includes('`{'))
+            return true;
+        if (m.includes('"[') || m.includes("'[") || m.includes('`['))
+            return true;
+        return /["'`]\s*[\[{]/.test(m);
+    }
+    maybePushJsonObjectNotStringSuggestion(suggestions) {
+        if (suggestions.includes(ValidationEngine_1.JSON_OBJECT_NOT_STRING_SUGGESTION))
+            return;
+        suggestions.push(ValidationEngine_1.JSON_OBJECT_NOT_STRING_SUGGESTION);
+    }
+    uniqueSuggestions(values) {
+        const out = [];
+        for (const v of values) {
+            if (!v)
+                continue;
+            if (out.includes(v))
+                continue;
+            out.push(v);
+        }
+        return out;
+    }
+    formatDefaultContainsMessage(value) {
+        if (typeof value !== 'string') {
+            return 'Output must include the required substring.';
+        }
+        const snippet = value.trim();
+        const looksJsonLike = snippet.startsWith('{') ||
+            snippet.startsWith('[') ||
+            snippet.includes('"') ||
+            snippet.includes(':');
+        if (looksJsonLike) {
+            return `Output must include this literal JSON snippet (not a JSON-encoded string): ${snippet}`;
+        }
+        return `Output must include: ${snippet}`;
+    }
     validateLoopStep(step, workflow) {
         const enhancedResult = this.enhancedLoopValidator.validateLoopStep(step);
         const issues = [];
@@ -366,6 +444,7 @@ let ValidationEngine = class ValidationEngine {
                 if (loopResult.info) {
                     info.push(...loopResult.info.map(i => `Step '${step.id}': ${i}`));
                 }
+                this.collectQuotedJsonValidationMessageWarnings(step, `Step '${step.id}'`, warnings);
             }
             else {
                 if (!step.id) {
@@ -377,6 +456,7 @@ let ValidationEngine = class ValidationEngine {
                 if (!step.prompt) {
                     issues.push(`Step '${step.id}' missing required prompt`);
                 }
+                this.collectQuotedJsonValidationMessageWarnings(step, `Step '${step.id}'`, warnings);
                 const callValidation = this.validateStepFunctionCalls(step, workflow.definition.functionDefinitions || []);
                 if (!callValidation.valid) {
                     issues.push(...callValidation.issues.map(i => `Step '${step.id}': ${i}`));
@@ -413,6 +493,47 @@ let ValidationEngine = class ValidationEngine {
             info: info.length > 0 ? info : undefined
         };
     }
+    collectQuotedJsonValidationMessageWarnings(stepLike, prefix, warnings) {
+        const criteria = stepLike?.validationCriteria;
+        if (!criteria)
+            return;
+        const msgs = this.collectValidationRuleMessages(criteria);
+        for (const m of msgs) {
+            if (!this.looksLikeQuotedJsonSnippet(m))
+                continue;
+            warnings.push(`${prefix}: validationCriteria.message appears to contain a quoted JSON snippet. ` +
+                `Agents often respond with a JSON-encoded string (escaping quotes) instead of a JSON object. ` +
+                `Prefer describing the required object/keys without quoting the JSON (or use schema validation).`);
+            return;
+        }
+    }
+    collectValidationRuleMessages(criteria) {
+        if (Array.isArray(criteria)) {
+            const msgs = [];
+            for (const r of criteria) {
+                if (r && typeof r === 'object' && typeof r.message === 'string')
+                    msgs.push(r.message);
+            }
+            return msgs;
+        }
+        if (this.isValidationRule(criteria)) {
+            return typeof criteria.message === 'string' ? [String(criteria.message)] : [];
+        }
+        if (this.isValidationComposition(criteria)) {
+            const msgs = [];
+            const c = criteria;
+            if (Array.isArray(c.and))
+                for (const child of c.and)
+                    msgs.push(...this.collectValidationRuleMessages(child));
+            if (Array.isArray(c.or))
+                for (const child of c.or)
+                    msgs.push(...this.collectValidationRuleMessages(child));
+            if (c.not)
+                msgs.push(...this.collectValidationRuleMessages(c.not));
+            return msgs;
+        }
+        return [];
+    }
     isValidVariableName(name) {
         return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
     }
@@ -472,7 +593,10 @@ let ValidationEngine = class ValidationEngine {
     }
 };
 exports.ValidationEngine = ValidationEngine;
-exports.ValidationEngine = ValidationEngine = __decorate([
+ValidationEngine.DEFAULT_FAILURE_SUGGESTION = 'Review validation criteria and adjust output accordingly.';
+ValidationEngine.JSON_OBJECT_NOT_STRING_SUGGESTION = 'If you are returning JSON, return an object/array directly (not a JSON-encoded string). Do not wrap it in quotes or escape quotes.';
+ValidationEngine.JSON_STRING_CONTAINS_JSON_SUGGESTION = 'It looks like you returned a JSON string that itself contains JSON. Remove the outer quotes and return the JSON object/array directly.';
+exports.ValidationEngine = ValidationEngine = ValidationEngine_1 = __decorate([
     (0, tsyringe_1.singleton)(),
     __param(0, (0, tsyringe_1.inject)(enhanced_loop_validator_1.EnhancedLoopValidator)),
     __metadata("design:paramtypes", [enhanced_loop_validator_1.EnhancedLoopValidator])

package/dist/application/services/workflow-interpreter.d.ts

@@ -24,7 +24,7 @@ export declare class WorkflowInterpreter {
     private ensureRunning;
     private nextTopLevel;
     private nextInCurrentLoop;
-    private shouldContinueLoop;
+    private projectLoopContextAtIteration;
     private projectLoopContext;
     private lookupStepInstance;
     private materializeStep;