bpmnlint-plugin-camunda-compat 2.59.2 → 2.60.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "2.59.2",
+  "version": "2.60.1",
   "description": "A bpmnlint plug-in for Camunda compatibility",
   "main": "index.js",
   "scripts": {

package/rules/camunda-cloud/agent-tool-output-key.js

@@ -15,10 +15,12 @@ const { annotateRule } = require('../helper');
  * or a part like `toolCallResult.statusCode`), a script task or called decision
  * `resultVariable`, or a connector `resultVariable`/`resultExpression` header.
  *
- * The rule warns once per tool: on the element that actually miswrote a
- * result-shaped variable, when the tool flow writes some but none of them is
- * `toolCallResult` (misdirection or wrong casing); on the entry activity when
- * the flow writes none at all, since there's no single offending element to
+ * A wrong-casing near-miss (`toolcallresult`, `TOOLCALLRESULT`, ...) is always
+ * reported on the element that wrote it, even when a sibling write already
+ * sets `toolCallResult` correctly — case-sensitive engines never read it.
+ * Other miswrites are reported individually per row only while no valid
+ * `toolCallResult` exists. When the flow writes none at all, the rule reports
+ * once on the entry activity, since there's no single offending element to
  * point to (the agent gets no completion signal and may retry or hallucinate
  * an outcome). Results written from arbitrary FEEL expressions are not
  * statically detectable.
@@ -47,27 +49,39 @@ module.exports = skipInNonExecutableProcess(function(config = {}) {
 
     const hasResult = channels.some(isToolCallResultChannel);
     if (!hasResult) {
-      const casingMismatch = channels.find(isToolCallResultCasingMismatch);
 
-      if (casingMismatch) {
-        reportErrors(casingMismatch.element, reporter, {
-          message: `Wrong casing "${getCasingMismatchText(casingMismatch)}": use toolCallResult (case-sensitive).`,
+      // Every channel here is a miswrite (none matched toolCallResult), so
+      // each is reported on the element that wrote it. A wrong-casing
+      // near-miss gets the more specific guidance.
+      for (const channel of channels) {
+        if (isToolCallResultCasingMismatch(channel)) {
+          reportErrors(channel.element, reporter, {
+            message: `Wrong casing "${getCasingMismatchText(channel)}": use toolCallResult (case-sensitive).`,
+            data: { type: ERROR_TYPES.AGENT_TOOL_OUTPUT_KEY_CASING_INVALID },
+            path: getChannelPath(channel),
+          });
+        } else {
+          reportErrors(channel.element, reporter, {
+            message: '"toolCallResult" output is not mapped.',
+            data: { type: ERROR_TYPES.AGENT_TOOL_OUTPUT_KEY_INVALID },
+            path: getChannelPath(channel),
+          });
+        }
+      }
+      return;
+    }
+
+    // Miscased near-misses are reported even when a sibling already sets
+    // toolCallResult correctly. Casing variants never satisfy
+    // isToolCallResultChannel, so the overwrite check below ignores them.
+    for (const channel of channels) {
+      if (isToolCallResultCasingMismatch(channel)) {
+        reportErrors(channel.element, reporter, {
+          message: `Wrong casing "${getCasingMismatchText(channel)}": use toolCallResult (case-sensitive).`,
           data: { type: ERROR_TYPES.AGENT_TOOL_OUTPUT_KEY_CASING_INVALID },
-          path: getChannelPath(casingMismatch),
+          path: getChannelPath(channel),
         });
-        return;
       }
-
-      // Every channel here is a miswrite (none matched toolCallResult), so
-      // the first one is a real misdirected write; report on the element
-      // that actually wrote it, not the tool's entry.
-      const misdirected = channels[ 0 ];
-      reportErrors(misdirected.element, reporter, {
-        message: '"toolCallResult" output is not mapped.',
-        data: { type: ERROR_TYPES.AGENT_TOOL_OUTPUT_KEY_INVALID },
-        path: getChannelPath(misdirected),
-      });
-      return;
     }
 
     // toolCallResult is set somewhere, but assigning it more than once
@@ -267,7 +281,7 @@ function isToolCallResultChannel({ kind, value }) {
 // case-insensitive name matching for fromAi().
 function isToolCallResultCasingMismatch({ kind, value }) {
   if (kind === 'resultExpression') {
-    return /\btoolcallresult\b/i.test(value) && !/\btoolCallResult\b/.test(value);
+    return !!getResultExpressionCasingMismatch(value);
   }
 
   const lower = value.toLowerCase();
@@ -276,13 +290,21 @@ function isToolCallResultCasingMismatch({ kind, value }) {
   return isCasingVariant && !isToolCallResultChannel({ kind, value });
 }
 
+// The first miscased toolCallResult token in a FEEL expression, or null when
+// every occurrence is cased correctly. Tokens are judged individually, so a
+// correct occurrence never excuses a miscased sibling in the same expression.
+function getResultExpressionCasingMismatch(value) {
+  const tokens = value.match(/\btoolcallresult\b/gi) || [];
+
+  return tokens.find(token => token !== 'toolCallResult') || null;
+}
+
 // The mismatched word itself, not the whole expression, for resultExpression
 // channels (a connector header value is a full FEEL expression, e.g.
 // `={toolcallresult: response.body}`).
 function getCasingMismatchText({ kind, value }) {
   if (kind === 'resultExpression') {
-    const match = value.match(/\btoolcallresult\b/i);
-    return match ? match[0] : value;
+    return getResultExpressionCasingMismatch(value) || value;
   }
 
   return value;