@travisliu/open-dynamic-workflow 0.3.0 → 0.3.5

package/dist/workflow/validate.js

@@ -74,6 +74,7 @@ function getObjectLiteralProperty(node, name) {
 }
 export function validateWorkflow(workflow, options) {
     const issues = [];
+    const loopLabelsSeen = new Set();
     const sourceFile = ts.createSourceFile(workflow.sourcePath, workflow.sourceText, ts.ScriptTarget.Latest, true);
     // Find the exported default workflow function to get its context parameter name
     const contextParameterNames = new Set(["ctx", "context"]);
@@ -139,7 +140,7 @@ export function validateWorkflow(workflow, options) {
             report(idArg, "Shared agent ID must be a string literal.");
         }
     }
-    function validateSharedAgentInput(idArg, inputArg, isDefinitionForm = false) {
+    function validateSharedAgentInput(idArg, inputArg) {
         if (!options.sharedAgentRegistry || !idArg || !ts.isStringLiteral(idArg)) {
             return;
         }
@@ -149,7 +150,7 @@ export function validateWorkflow(workflow, options) {
             return;
         }
         const schema = entry.definition.inputSchema;
-        let parsedInput = parseStaticProperties(inputArg);
+        const parsedInput = parseStaticProperties(inputArg);
         if (parsedInput === undefined) {
             if (!inputArg) {
                 try {
@@ -162,7 +163,9 @@ export function validateWorkflow(workflow, options) {
                         }
                     }
                 }
-                catch (err) { }
+                catch {
+                    // ignore validation errors
+                }
             }
             return;
         }
@@ -194,7 +197,9 @@ export function validateWorkflow(workflow, options) {
                 }
             }
         }
-        catch (err) { }
+        catch {
+            // ignore validation errors
+        }
     }
     function validateInputAgainstSchema(name, schema, argsExpr) {
         if (argsExpr === undefined) {
@@ -232,7 +237,9 @@ export function validateWorkflow(workflow, options) {
                 }
             }
         }
-        catch (err) { }
+        catch {
+            // ignore validation errors
+        }
     }
     function validateWorkflowCall(node, isContextForm, contextName = "workflow") {
         const firstArg = node.arguments[0];
@@ -321,7 +328,7 @@ export function validateWorkflow(workflow, options) {
         const firstArg = node.arguments[0];
         const callPrefix = isContextForm ? `${contextName}.tool()` : "tool()";
         if (isForbiddenContext) {
-            report(node, `${callPrefix} is not allowed in this context (parallel, pipeline stage, or shared agent).`);
+            report(node, `${callPrefix} is not allowed in this context (parallel, pipeline stage, loop round, or shared agent).`);
         }
         if (!firstArg) {
             report(node, `${callPrefix} requires an object literal argument.`);
@@ -418,6 +425,277 @@ export function validateWorkflow(workflow, options) {
             report(firstArg, `${callPrefix} is missing required 'args' property.`);
         }
     }
+    function validateLoopCall(node, isContextForm, contextName = "ctx", isForbiddenContext = false, functionDepth = 0, isInsideParallel = false, isInsideLoopRun = false, isInsideMainWorkflow = false) {
+        const callPrefix = isContextForm ? `${contextName}.loop()` : "loop()";
+        if (isInsideParallel) {
+            report(node, `loop() inside parallel() is not supported to prevent state overwrites.`);
+        }
+        if (isInsideLoopRun) {
+            report(node, `Nested loops are not supported to prevent state overwrites.`);
+        }
+        if (functionDepth > 0 && !isInsideMainWorkflow && !isInsideLoopRun) {
+            report(node, `loop() is not allowed inside helper functions or recursive scopes to prevent state overwrites.`);
+        }
+        if (node.arguments.length !== 1) {
+            report(node, `${callPrefix} now accepts exactly one object argument.`);
+            return;
+        }
+        const firstArg = node.arguments[0];
+        if (!firstArg) {
+            report(node, `${callPrefix} now accepts exactly one object argument.`);
+            return;
+        }
+        if (!ts.isObjectLiteralExpression(firstArg)) {
+            if (isStaticValue(firstArg)) {
+                report(firstArg, `${callPrefix} argument must be an object literal.`);
+            }
+            visit(firstArg, isForbiddenContext, functionDepth, isInsideLoopRun, new Set(), isInsideParallel, isInsideMainWorkflow);
+            return;
+        }
+        const propsMap = new Map();
+        const seenKeys = new Set();
+        for (const prop of firstArg.properties) {
+            if (ts.isSpreadAssignment(prop)) {
+                report(prop, `${callPrefix} does not support spread properties.`);
+                continue;
+            }
+            if (ts.isShorthandPropertyAssignment(prop)) {
+                const key = prop.name.text;
+                report(prop, `${callPrefix} does not support shorthand property '${key}'.`);
+                continue;
+            }
+            if (ts.isMethodDeclaration(prop)) {
+                if (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name)) {
+                    report(prop, `${callPrefix} does not support computed method names.`);
+                    continue;
+                }
+                const key = prop.name.text;
+                if (key !== "run") {
+                    report(prop, `${callPrefix} does not support method properties for '${key}'.`);
+                }
+                propsMap.set(key, prop);
+                seenKeys.add(key);
+                continue;
+            }
+            if (ts.isPropertyAssignment(prop)) {
+                if (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name)) {
+                    report(prop, `${callPrefix} does not support computed property names.`);
+                    continue;
+                }
+                const key = prop.name.text;
+                propsMap.set(key, prop.initializer);
+                seenKeys.add(key);
+                continue;
+            }
+            report(prop, `${callPrefix} contains unsupported property type.`);
+        }
+        const allowedKeys = new Set(["label", "initialState", "options", "run"]);
+        for (const key of seenKeys) {
+            if (key === "runRound") {
+                report(firstArg, `${callPrefix} does not support 'runRound'. Use 'run' instead.`);
+            }
+            else if (!allowedKeys.has(key)) {
+                report(firstArg, `${callPrefix} contains unsupported top-level key '${key}'.`);
+            }
+        }
+        const requiredKeys = ["label", "initialState", "options", "run"];
+        for (const reqKey of requiredKeys) {
+            if (!seenKeys.has(reqKey)) {
+                report(firstArg, `${callPrefix} is missing required '${reqKey}' property.`);
+            }
+        }
+        const labelInit = propsMap.get("label");
+        if (labelInit && isStaticValue(labelInit)) {
+            const labelVal = parseStaticProperties(labelInit);
+            if (typeof labelVal !== "string") {
+                report(labelInit, "label must be a string literal.");
+            }
+            else if (labelVal.trim() === "") {
+                report(labelInit, "label cannot be empty.");
+            }
+            else {
+                const normalizedLabel = labelVal
+                    .toLowerCase()
+                    .trim()
+                    .replace(/[^a-z0-9_.:-]+/g, "-")
+                    .replace(/^-+|-+$/g, "");
+                if (loopLabelsSeen.has(normalizedLabel)) {
+                    report(labelInit, `Duplicate loop label detected: '${labelVal}'. All loop labels in a workflow must be unique.`);
+                }
+                else {
+                    loopLabelsSeen.add(normalizedLabel);
+                }
+            }
+        }
+        if (labelInit) {
+            visit(labelInit, isForbiddenContext, functionDepth);
+        }
+        const initialStateInit = propsMap.get("initialState");
+        if (initialStateInit) {
+            visit(initialStateInit, isForbiddenContext, functionDepth);
+        }
+        const optionsInit = propsMap.get("options");
+        if (optionsInit) {
+            if (ts.isObjectLiteralExpression(optionsInit)) {
+                const allowedLoopOptionKeys = new Set(["failureMode", "maxRounds", "timeoutMs"]);
+                const deprecatedKeys = new Set(["stopWhen", "nextState", "onFailureState", "resultMode", "metadata"]);
+                const optPropsMap = new Map();
+                const optSeenKeys = new Set();
+                for (const prop of optionsInit.properties) {
+                    if (ts.isSpreadAssignment(prop)) {
+                        report(prop, `${callPrefix} does not support spread properties in options.`);
+                        continue;
+                    }
+                    if (!ts.isPropertyAssignment(prop)) {
+                        report(prop, `${callPrefix} does not support shorthand or method properties in options.`);
+                        continue;
+                    }
+                    if (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name)) {
+                        report(prop.name, `${callPrefix} does not support computed property names in options.`);
+                        continue;
+                    }
+                    const key = prop.name.text;
+                    if (deprecatedKeys.has(key)) {
+                        report(prop.name, `${callPrefix} option '${key}' is deprecated or unsupported.`);
+                        continue;
+                    }
+                    if (!allowedLoopOptionKeys.has(key)) {
+                        report(prop.name, `${callPrefix} options contain unsupported key '${key}'.`);
+                        continue;
+                    }
+                    optPropsMap.set(key, prop.initializer);
+                    optSeenKeys.add(key);
+                }
+                if (!optSeenKeys.has("maxRounds")) {
+                    report(optionsInit, `${callPrefix} options is missing required 'maxRounds'.`);
+                }
+                for (const [key, init] of optPropsMap.entries()) {
+                    const isStatic = isStaticValue(init);
+                    const staticVal = isStatic ? parseStaticProperties(init) : undefined;
+                    if (key === "maxRounds") {
+                        if (isStatic) {
+                            const ceiling = options.maxLoopRounds ?? 20;
+                            if (typeof staticVal !== "number" || isNaN(staticVal) || !Number.isInteger(staticVal) || staticVal < 1) {
+                                report(init, "maxRounds must be a positive integer.");
+                            }
+                            else if (staticVal > ceiling) {
+                                report(init, `maxRounds (${staticVal}) exceeds the configured ceiling of ${ceiling}.`);
+                            }
+                        }
+                    }
+                    else if (key === "timeoutMs") {
+                        if (isStatic) {
+                            if (typeof staticVal !== "number" || isNaN(staticVal) || !Number.isInteger(staticVal) || staticVal <= 0) {
+                                report(init, "timeoutMs must be a positive integer.");
+                            }
+                        }
+                    }
+                    else if (key === "failureMode") {
+                        if (isStatic) {
+                            if (typeof staticVal !== "string") {
+                                report(init, "failureMode must be a string literal.");
+                            }
+                            else if (staticVal !== "throw" && staticVal !== "settled") {
+                                report(init, "failureMode must be 'throw' or 'settled'.");
+                            }
+                        }
+                    }
+                }
+            }
+            else if (isStaticValue(optionsInit)) {
+                report(optionsInit, `${callPrefix} options must be an object literal.`);
+            }
+            visit(optionsInit, isForbiddenContext, functionDepth);
+        }
+        const runInit = propsMap.get("run");
+        if (runInit) {
+            if (!ts.isArrowFunction(runInit) && !ts.isFunctionExpression(runInit) && !ts.isMethodDeclaration(runInit)) {
+                report(runInit, `${callPrefix} 'run' property must be a function expression, arrow function, or method property.`);
+            }
+            else {
+                const params = runInit.parameters;
+                const localLoopContextNames = new Set();
+                if (params && params.length >= 2) {
+                    const secondParam = params[1];
+                    if (secondParam && ts.isIdentifier(secondParam.name)) {
+                        localLoopContextNames.add(secondParam.name.text);
+                    }
+                }
+                if (localLoopContextNames.size === 0) {
+                    localLoopContextNames.add("ctx");
+                    localLoopContextNames.add("context");
+                }
+                function validateReturnExpression(expr) {
+                    let unwrapped = expr;
+                    while (ts.isParenthesizedExpression(unwrapped)) {
+                        unwrapped = unwrapped.expression;
+                    }
+                    if (ts.isObjectLiteralExpression(unwrapped)) {
+                        const retKeys = new Set();
+                        let doneInit;
+                        for (const prop of unwrapped.properties) {
+                            if (ts.isPropertyAssignment(prop) || ts.isMethodDeclaration(prop)) {
+                                const propName = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ? prop.name.text : "";
+                                if (propName) {
+                                    retKeys.add(propName);
+                                    if (propName === "done" && ts.isPropertyAssignment(prop)) {
+                                        doneInit = prop.initializer;
+                                    }
+                                }
+                            }
+                            else if (ts.isShorthandPropertyAssignment(prop)) {
+                                const propName = prop.name.text;
+                                retKeys.add(propName);
+                            }
+                        }
+                        if (retKeys.has("result")) {
+                            report(unwrapped, "Loop run return must not contain 'result'.");
+                        }
+                        if (!retKeys.has("done")) {
+                            report(unwrapped, "Loop run return must contain 'done'.");
+                        }
+                        if (!retKeys.has("nextState")) {
+                            report(unwrapped, "Loop run return must contain 'nextState'.");
+                        }
+                        if (doneInit && isStaticValue(doneInit)) {
+                            const doneVal = parseStaticProperties(doneInit);
+                            if (typeof doneVal !== "boolean") {
+                                report(doneInit, "done must be a boolean.");
+                            }
+                        }
+                    }
+                }
+                function findReturnStatements(n, returns) {
+                    if (ts.isReturnStatement(n)) {
+                        returns.push(n);
+                        return;
+                    }
+                    if (ts.isFunctionDeclaration(n) || ts.isFunctionExpression(n) || ts.isArrowFunction(n) || ts.isMethodDeclaration(n)) {
+                        return;
+                    }
+                    ts.forEachChild(n, child => findReturnStatements(child, returns));
+                }
+                if (runInit.body) {
+                    if (ts.isBlock(runInit.body)) {
+                        const returns = [];
+                        findReturnStatements(runInit.body, returns);
+                        for (const ret of returns) {
+                            if (ret.expression) {
+                                validateReturnExpression(ret.expression);
+                            }
+                            else {
+                                report(ret, "Loop run return must contain 'done' and 'nextState'.");
+                            }
+                        }
+                    }
+                    else {
+                        validateReturnExpression(runInit.body);
+                    }
+                }
+                visit(runInit, true, functionDepth, true, localLoopContextNames);
+            }
+        }
+    }
     function validateAgentCall(node, isContextForm, contextName = "ctx") {
         const firstArg = node.arguments[0];
         const callPrefix = isContextForm ? `${contextName}.agent()` : "agent()";
@@ -511,7 +789,7 @@ export function validateWorkflow(workflow, options) {
         if (definitionProp) {
             const definitionArg = ts.isPropertyAssignment(definitionProp) ? definitionProp.initializer : undefined;
             validateSharedAgentId(definitionArg);
-            validateSharedAgentInput(definitionArg, firstArg, true);
+            validateSharedAgentInput(definitionArg, firstArg);
         }
         else {
             if (!promptProp && !hasSpread) {
@@ -536,19 +814,21 @@ export function validateWorkflow(workflow, options) {
             }
         }
     }
-    function isToolOrCtxTool(node) {
+    function isToolOrCtxTool(node, currentLoopCtxNames) {
         // direct tool
         if (ts.isIdentifier(node) && node.text === "tool")
             return true;
         // ctx.tool
         if (ts.isPropertyAccessExpression(node) &&
-            ts.isIdentifier(node.expression) && contextParameterNames.has(node.expression.text) &&
+            ts.isIdentifier(node.expression) &&
+            (contextParameterNames.has(node.expression.text) || (currentLoopCtxNames && currentLoopCtxNames.has(node.expression.text))) &&
             node.name.text === "tool") {
             return true;
         }
         // ctx["tool"]
         if (ts.isElementAccessExpression(node) &&
-            ts.isIdentifier(node.expression) && contextParameterNames.has(node.expression.text) &&
+            ts.isIdentifier(node.expression) &&
+            (contextParameterNames.has(node.expression.text) || (currentLoopCtxNames && currentLoopCtxNames.has(node.expression.text))) &&
             ts.isStringLiteral(node.argumentExpression) && node.argumentExpression.text === "tool") {
             return true;
         }
@@ -557,39 +837,39 @@ export function validateWorkflow(workflow, options) {
         if (ts.isPropertyAccessExpression(node)) {
             const name = node.name.text;
             if (name === "bind" || name === "call" || name === "apply") {
-                if (isToolOrCtxTool(node.expression))
+                if (isToolOrCtxTool(node.expression, currentLoopCtxNames))
                     return true;
             }
         }
         if (ts.isCallExpression(node)) {
-            if (isToolOrCtxTool(node.expression))
+            if (isToolOrCtxTool(node.expression, currentLoopCtxNames))
                 return true;
         }
         return false;
     }
-    function isLikelyWorkflowContext(node) {
-        if (ts.isIdentifier(node) && contextParameterNames.has(node.text))
+    function isLikelyWorkflowContext(node, currentLoopCtxNames) {
+        if (ts.isIdentifier(node) && (contextParameterNames.has(node.text) || (currentLoopCtxNames && currentLoopCtxNames.has(node.text))))
             return true;
         return false;
     }
-    function checkBindingForToolAlias(name, initializer) {
+    function checkBindingForToolAlias(name, initializer, currentLoopCtxNames) {
         if (ts.isObjectBindingPattern(name)) {
             for (const element of name.elements) {
                 const propName = element.propertyName ? (ts.isIdentifier(element.propertyName) ? element.propertyName.text : undefined) : (ts.isIdentifier(element.name) ? element.name.text : undefined);
                 if (propName === "tool") {
                     // If we have an initializer, check if it's the context.
                     // If no initializer (like in parameter), we assume it's aliasing if the parameter looks like a context.
-                    if (!initializer || isLikelyWorkflowContext(initializer)) {
+                    if (!initializer || isLikelyWorkflowContext(initializer, currentLoopCtxNames)) {
                         report(element, "Aliasing tool() is not allowed. Use it directly as tool() or ctx.tool().");
                     }
                 }
                 if (element.name && ts.isObjectBindingPattern(element.name)) {
-                    checkBindingForToolAlias(element.name, initializer);
+                    checkBindingForToolAlias(element.name, initializer, currentLoopCtxNames);
                 }
             }
         }
     }
-    function visit(node, isForbiddenContext = false, functionDepth = 0) {
+    function visit(node, isForbiddenContext = false, functionDepth = 0, isInsideLoopRun = false, loopContextNames = new Set(), isInsideParallel = false, isInsideMainWorkflow = false) {
         // Skip the metadata declaration statement (export const meta = { ... })
         if (sourceFile.statements.length > 0 && node === sourceFile.statements[0]) {
             if (ts.isVariableStatement(node) && node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
@@ -604,24 +884,27 @@ export function validateWorkflow(workflow, options) {
         }
         let nextForbiddenContext = isForbiddenContext;
         let nextFunctionDepth = functionDepth;
+        const nextInsideLoopRun = isInsideLoopRun;
+        let nextInsideMainWorkflow = isInsideMainWorkflow;
+        const nextLoopContextNames = new Set(loopContextNames);
         if (ts.isVariableDeclaration(node)) {
             const init = node.initializer;
             if (init) {
-                if (isToolOrCtxTool(init)) {
+                if (isToolOrCtxTool(init, nextLoopContextNames)) {
                     report(node, "Aliasing tool() is not allowed. Use it directly as tool() or ctx.tool().");
                 }
-                checkBindingForToolAlias(node.name, init);
+                checkBindingForToolAlias(node.name, init, nextLoopContextNames);
             }
             else {
-                checkBindingForToolAlias(node.name);
+                checkBindingForToolAlias(node.name, undefined, nextLoopContextNames);
             }
         }
         if (ts.isParameter(node)) {
-            checkBindingForToolAlias(node.name);
+            checkBindingForToolAlias(node.name, undefined, nextLoopContextNames);
         }
         if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
             const rhs = node.right;
-            if (isToolOrCtxTool(rhs)) {
+            if (isToolOrCtxTool(rhs, nextLoopContextNames)) {
                 report(node, "Aliasing tool() is not allowed. Use it directly as tool() or ctx.tool().");
             }
         }
@@ -629,6 +912,7 @@ export function validateWorkflow(workflow, options) {
             nextFunctionDepth++;
             if (nextFunctionDepth > 1) {
                 nextForbiddenContext = true;
+                nextInsideMainWorkflow = false;
             }
             else if (nextFunctionDepth === 1) {
                 // Only the default exported function (the main workflow) is allowed to contain tools.
@@ -643,6 +927,10 @@ export function validateWorkflow(workflow, options) {
                 }
                 if (!isMainWorkflow) {
                     nextForbiddenContext = true;
+                    nextInsideMainWorkflow = false;
+                }
+                else {
+                    nextInsideMainWorkflow = true;
                 }
             }
         }
@@ -650,7 +938,7 @@ export function validateWorkflow(workflow, options) {
             const callee = node.expression;
             // Reject tool being passed as an argument
             for (const arg of node.arguments) {
-                if (isToolOrCtxTool(arg)) {
+                if (isToolOrCtxTool(arg, nextLoopContextNames)) {
                     report(arg, "Aliasing tool() is not allowed. Use it directly as tool() or ctx.tool().");
                 }
             }
@@ -742,21 +1030,29 @@ export function validateWorkflow(workflow, options) {
                         if (idx === 1) {
                             // stagesArg and its children (the stage objects and their 'run' methods)
                             // need to recursively forbid tools.
-                            visit(arg, true, nextFunctionDepth);
+                            visit(arg, true, nextFunctionDepth, nextInsideLoopRun, nextLoopContextNames, isInsideParallel, false);
                         }
                         else {
-                            visit(arg, nextForbiddenContext, nextFunctionDepth);
+                            visit(arg, nextForbiddenContext, nextFunctionDepth, nextInsideLoopRun, nextLoopContextNames, isInsideParallel, nextInsideMainWorkflow);
                         }
                     });
                     return;
                 }
                 else if (calleeText === "parallel") {
                     nextForbiddenContext = true;
+                    node.arguments.forEach((arg) => {
+                        visit(arg, true, nextFunctionDepth, nextInsideLoopRun, nextLoopContextNames, true, nextInsideMainWorkflow);
+                    });
+                    return;
+                }
+                else if (calleeText === "loop") {
+                    validateLoopCall(node, false, "ctx", isForbiddenContext, functionDepth, isInsideParallel, isInsideLoopRun, isInsideMainWorkflow);
+                    return;
                 }
                 else if (calleeText === "defineAgent") {
                     const firstArg = node.arguments[0];
                     if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-                        visit(firstArg, true, nextFunctionDepth);
+                        visit(firstArg, true, nextFunctionDepth, nextInsideLoopRun, nextLoopContextNames, isInsideParallel, false);
                         return;
                     }
                 }
@@ -782,33 +1078,59 @@ export function validateWorkflow(workflow, options) {
             else if (ts.isPropertyAccessExpression(callee)) {
                 const obj = callee.expression;
                 const prop = callee.name;
-                if (ts.isIdentifier(obj) && contextParameterNames.has(obj.text)) {
-                    if (prop.text === "agent") {
-                        validateAgentCall(node, true, obj.text);
-                    }
-                    else if (prop.text === "workflow") {
-                        validateWorkflowCall(node, true, obj.text);
+                if (ts.isIdentifier(obj)) {
+                    const isContextParam = contextParameterNames.has(obj.text) || nextLoopContextNames.has(obj.text);
+                    if (isContextParam) {
+                        if (prop.text === "agent") {
+                            validateAgentCall(node, true, obj.text);
+                        }
+                        else if (prop.text === "workflow") {
+                            validateWorkflowCall(node, true, obj.text);
+                        }
+                        else if (prop.text === "loop") {
+                            validateLoopCall(node, true, obj.text, isForbiddenContext, functionDepth, isInsideParallel, isInsideLoopRun, isInsideMainWorkflow);
+                            return;
+                        }
+                        else if (prop.text === "tool") {
+                            validateToolCall(node, true, nextForbiddenContext, obj.text);
+                        }
                     }
-                    else if (prop.text === "tool") {
-                        validateToolCall(node, true, nextForbiddenContext, obj.text);
+                    if (nextLoopContextNames.has(obj.text) || (nextInsideLoopRun && (obj.text === "ctx" || obj.text === "context"))) {
+                        if (prop.text === "break") {
+                            report(node, `${obj.text}.break() is not supported inside loop run callback.`);
+                        }
+                        else if (prop.text === "parallel") {
+                            report(node, `${obj.text}.parallel() is not supported inside loop run callback. Use top-level parallel() around loop task thunks instead.`);
+                        }
                     }
                 }
             }
             else if (ts.isElementAccessExpression(callee)) {
                 const obj = callee.expression;
                 const arg = callee.argumentExpression;
-                if (ts.isIdentifier(obj) && contextParameterNames.has(obj.text) && ts.isStringLiteral(arg)) {
+                if (ts.isIdentifier(obj) && ts.isStringLiteral(arg)) {
                     const propName = arg.text;
-                    if (["agent", "workflow", "tool"].includes(propName)) {
-                        report(node, `Computed access forms like ${obj.text}["${propName}"]() are not allowed. Use direct property access like ${obj.text}.${propName}() instead.`);
-                        if (propName === "agent") {
-                            validateAgentCall(node, true, obj.text);
+                    const isContextParam = contextParameterNames.has(obj.text) || nextLoopContextNames.has(obj.text);
+                    if (isContextParam) {
+                        if (["agent", "workflow", "tool"].includes(propName)) {
+                            report(node, `Computed access forms like ${obj.text}["${propName}"]() are not allowed. Use direct property access like ${obj.text}.${propName}() instead.`);
+                            if (propName === "agent") {
+                                validateAgentCall(node, true, obj.text);
+                            }
+                            else if (propName === "workflow") {
+                                validateWorkflowCall(node, true, obj.text);
+                            }
+                            else if (propName === "tool") {
+                                validateToolCall(node, true, nextForbiddenContext, obj.text);
+                            }
                         }
-                        else if (propName === "workflow") {
-                            validateWorkflowCall(node, true, obj.text);
+                    }
+                    if (nextLoopContextNames.has(obj.text) || (nextInsideLoopRun && (obj.text === "ctx" || obj.text === "context"))) {
+                        if (propName === "break") {
+                            report(node, `Computed access forms like ${obj.text}["break"]() are not allowed.`);
                         }
-                        else if (propName === "tool") {
-                            validateToolCall(node, true, nextForbiddenContext, obj.text);
+                        else if (propName === "parallel") {
+                            report(node, `${obj.text}.parallel() is not supported inside loop run callback. Use top-level parallel() around loop task thunks instead.`);
                         }
                     }
                 }
@@ -874,7 +1196,7 @@ export function validateWorkflow(workflow, options) {
                 }
             }
         }
-        ts.forEachChild(node, (child) => visit(child, nextForbiddenContext, nextFunctionDepth));
+        ts.forEachChild(node, (child) => visit(child, nextForbiddenContext, nextFunctionDepth, nextInsideLoopRun, nextLoopContextNames, isInsideParallel, nextInsideMainWorkflow));
     }
     visit(sourceFile);
     return issues;
@@ -1000,7 +1322,8 @@ export function validateRegistryDependencies(registry, options) {
             knownWorkflowNames,
             workflowInputSchemas,
             allowDynamicSharedAgentIds: options.allowDynamicSharedAgentIds,
-            toolRegistry: options.toolRegistry
+            toolRegistry: options.toolRegistry,
+            maxLoopRounds: options.maxLoopRounds
         });
         const localErrors = issues.filter(issue => issue.severity !== "warning").map(issue => issue.message);
         // Log warnings for checked workflows. To avoid duplicate warnings for root workflow (which was