bpmnlint-plugin-camunda-compat 2.59.0 → 2.59.2

package/package.json

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

package/rules/camunda-cloud/agent-fromai-contract.js

@@ -3,7 +3,7 @@ const { is } = require('bpmnlint-utils');
 const { getPath, pathConcat } = require('@bpmn-io/moddle-utils');
 
 const { findExtensionElement, findAncestorAdHocSubProcess, isAgenticAdHocSubProcess } = require('../utils/element');
-const { CORRECT_NAME, NAME_ALIASES, findFunctionInvocations, getPositionalArgs } = require('./utils/feel');
+const { CORRECT_NAME, NAME_ALIASES, findFunctionInvocations, getArgs } = require('./utils/feel');
 const { reportErrors } = require('../utils/reporter');
 const { ERROR_TYPES } = require('../utils/error-types');
 const { skipInNonExecutableProcess } = require('../utils/rule');
@@ -34,6 +34,10 @@ const { annotateRule } = require('../helper');
  *
  * A description that is simply absent (no argument, or an empty string) is
  * valid: the fromAi() description is optional, so neither rule reports it.
+ *
+ * Positional and named calls are equivalent, because
+ * FromAiTaggedParameterExtractor funnels both into the same five-argument
+ * call. Every check below therefore applies to both forms.
  */
 // ─── Constraint validators ────────────────────────────────────────────────────
 
@@ -214,9 +218,9 @@ module.exports = skipInNonExecutableProcess(function(config = {}) {
         continue;
       }
 
-      const args = getPositionalArgs(inv.node, expr);
+      const args = getArgs(inv.node, expr);
 
-      if (args.length === 0) {
+      if (!args[0]) {
         errors.push({
           message: 'fromAi() requires a key argument: a FEEL path like toolCall.url.',
           data: { type: ERROR_TYPES.AGENT_FEEL_KEY_MISSING },
@@ -229,7 +233,7 @@ module.exports = skipInNonExecutableProcess(function(config = {}) {
         errors.push(keyError);
       }
 
-      if (args.length >= 2) {
+      if (args[1]) {
         const descriptionError = validateDescriptionTypeInvalid(args[1]);
         if (descriptionError) {
           errors.push(descriptionError);
@@ -284,7 +288,7 @@ module.exports = skipInNonExecutableProcess(function(config = {}) {
 
       const expr = source.substring(1).trim();
       for (const inv of findFunctionInvocations(expr)) {
-        const args = getPositionalArgs(inv.node, expr);
+        const args = getArgs(inv.node, expr);
         const key = args[ 0 ];
         if (key && key.type === 'PathExpression' && key.text.startsWith('toolCall.')) {
           (keyOccurrences[ key.text ] = keyOccurrences[ key.text ] || []).push(input);

package/rules/camunda-cloud/utils/feel.js

@@ -34,11 +34,18 @@ const isFeelProperty = (node, propertyName, value) => {
 
 // ─── fromAi() lezer helpers ─────────────────────────────────────────────────
 // Used by agent-fromai-contract to locate fromAi() calls and read their
-// positional arguments.
+// arguments, written either positionally or as named parameters.
 
 const CORRECT_NAME = 'fromAi';
 const NAME_ALIASES = [ 'fromai', 'fromAI' ];
 
+// fromAi() signature, mirroring FromAiTaggedParameterExtractor in
+// camunda/camunda: it normalizes positional and named calls onto these same
+// five slots, so every downstream check reads one index for both call forms.
+// The list is also what tells a name the engine recognizes from a typo like
+// "valu", which the engine drops.
+const PARAMETER_NAMES = [ 'value', 'description', 'type', 'schema', 'options' ];
+
 function findFunctionInvocations(expr) {
   const tree = parser.parse(expr);
   const result = [];
@@ -65,18 +72,64 @@ function findFunctionInvocations(expr) {
   return result;
 }
 
-function getPositionalArgs(invocationNode, expr) {
+// Comments and error nodes are siblings of the real arguments, so reading them
+// as arguments would report a comment as the wrong key type, or an incomplete
+// call as a "⚠" one.
+const nextArgNode = node => {
+  while (node && node.type.isSkipped) {
+    node = node.nextSibling;
+  }
+  return node;
+};
+
+/**
+ * Reads a fromAi() call's arguments into an array indexed by PARAMETER_NAMES.
+ *
+ * A named call fills only the slots it mentions, so the array is sparse: for
+ * `fromAi(type: "number")` slot 2 is set while slot 0 is undefined. Callers
+ * must test individual slots for presence rather than read `args.length`.
+ */
+function getArgs(invocationNode, expr) {
+  const toArg = node => ({ type: node.type.name, text: expr.slice(node.from, node.to) });
+
   let child = invocationNode.firstChild;
   while (child) {
     if (child.type.name === 'PositionalParameters') {
       const args = [];
-      let arg = child.firstChild;
+      let arg = nextArgNode(child.firstChild);
       while (arg) {
-        args.push({ type: arg.type.name, text: expr.slice(arg.from, arg.to) });
-        arg = arg.nextSibling;
+        args.push(toArg(arg));
+        arg = nextArgNode(arg.nextSibling);
       }
       return args;
     }
+
+    if (child.type.name === 'NamedParameters') {
+
+      // Named arguments resolve by name, and their order in the call carries no
+      // meaning, so each one goes to its own slot. A name outside the signature
+      // is dropped, matching the engine, which reads the parameter map by name
+      // and never sees it.
+      const args = [];
+      let param = child.firstChild;
+      while (param) {
+        if (param.type.name === 'NamedParameter') {
+          const nameNode = param.firstChild;
+          const valueNode = nameNode && nextArgNode(nameNode.nextSibling);
+
+          if (nameNode && nameNode.type.name === 'ParameterName' && valueNode) {
+            const index = PARAMETER_NAMES.indexOf(expr.slice(nameNode.from, nameNode.to));
+
+            if (index !== -1) {
+              args[ index ] = toArg(valueNode);
+            }
+          }
+        }
+        param = param.nextSibling;
+      }
+      return args;
+    }
+
     child = child.nextSibling;
   }
   return [];
@@ -87,5 +140,5 @@ module.exports = {
   CORRECT_NAME,
   NAME_ALIASES,
   findFunctionInvocations,
-  getPositionalArgs
+  getArgs
 };

package/rules/utils/element.js

@@ -582,6 +582,22 @@ const TOOL_CONTAINER_PROPERTY = 'io.camunda.agenticai.toolContainer';
 // their AHSPs are agentic but carry no marker; the template id identifies them.
 const LEGACY_AI_AGENT_TEMPLATE = 'io.camunda.connectors.agenticai.aiagent.jobworker.v1';
 
+// The job worker type Camunda's AI Agent job-worker template assigns to the
+// AHSP's own zeebe:taskDefinition. Organizations sometimes publish a forked
+// element template (own modelerTemplate id, so LEGACY_AI_AGENT_TEMPLATE
+// doesn't match) while keeping the same job worker underneath, since the
+// fork still needs a worker subscribing to that type to execute it (#259).
+const AI_AGENT_JOB_WORKER_TYPE_PREFIX = 'io.camunda.agenticai:aiagent-job-worker:';
+
+function hasAiAgentJobWorkerType(node) {
+  const taskDefinition = findExtensionElement(node, 'zeebe:TaskDefinition');
+  const type = taskDefinition && taskDefinition.get('type');
+
+  return !!type && type.startsWith(AI_AGENT_JOB_WORKER_TYPE_PREFIX);
+}
+
+module.exports.hasAiAgentJobWorkerType = hasAiAgentJobWorkerType;
+
 function hasToolContainerProperty(node) {
   const properties = findExtensionElement(node, 'zeebe:Properties');
 
@@ -611,7 +627,9 @@ module.exports.hasToolContainerProperty = hasToolContainerProperty;
 //
 // Older AI Agent job-worker templates predate the property marker; they are
 // still agentic and are recognized by their (version-agnostic) element template
-// id (see LEGACY_AI_AGENT_TEMPLATE).
+// id (see LEGACY_AI_AGENT_TEMPLATE). Forked templates that don't carry that
+// id are still recognized by the underlying job worker type prefix (see
+// AI_AGENT_JOB_WORKER_TYPE_PREFIX), since that's what the fork must keep to run.
 function isAgenticAdHocSubProcess(ahsp, version) {
   if (hasToolContainerProperty(ahsp)) {
     return true;
@@ -621,6 +639,10 @@ function isAgenticAdHocSubProcess(ahsp, version) {
     return true;
   }
 
+  if (hasAiAgentJobWorkerType(ahsp)) {
+    return true;
+  }
+
   return !!version
     && greaterOrEqual(version, '8.10')
     && !!findExtensionElement(ahsp, 'zeebe:AgentDefinition');