@uipath/packager-tool-flow 1.197.0 → 1.198.0-preview.100

package/dist/ensure-process-bindings.d.ts

@@ -1,9 +1,9 @@
 import type { Workflow } from "@uipath/flow-core";
 import type { IToolLogger } from "@uipath/solutionpackager-tool-core";
 /**
- * Safety net: ensure every process/agent node in the workflow has corresponding
- * entries in the workflow `bindings` array and that `<bindings.*>` placeholders
- * in model.context are resolved to `=bindings.<id>` references.
+ * Safety net: ensure every process/agent/connector-tool node in the workflow has
+ * corresponding entries in the workflow `bindings` array and that `<bindings.*>`
+ * placeholders in model.context are resolved to `=bindings.<id>` references.
  *
  * This handles flows authored outside the CLI (e.g. direct file edits or
  * skill-generated files) where `addNodeToFlow` was never called, so the

package/dist/index.js

@@ -32,7 +32,7 @@ import {
 // package.json
 var package_default = {
   name: "@uipath/packager-tool-flow",
-  version: "1.197.0",
+  version: "1.198.0-preview.100",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -170,10 +170,14 @@ var PROCESS_NODE_PREFIXES = [
   "uipath.core.agent.",
   "uipath.core.api-workflow."
 ];
-var UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+var CONNECTOR_TOOL_PREFIX = "uipath.agent.resource.tool.connector.";
+var UNRESOLVED_BINDING_PATTERN = /^<bindings\.[^>]+>$/;
 function isProcessNode(nodeType) {
   return PROCESS_NODE_PREFIXES.some((prefix) => nodeType?.startsWith(prefix));
 }
+function isConnectorToolNode(nodeType) {
+  return nodeType?.startsWith(CONNECTOR_TOOL_PREFIX) ?? false;
+}
 function extractProcessGuid(nodeType) {
   const match = nodeType.match(/^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i);
   if (!match) {
@@ -225,13 +229,50 @@ function resolveContextPlaceholders(context, storedName, storedFolder) {
     }
   }
 }
+function createConnectorToolBindings(node, definition) {
+  const model = definition.model;
+  const detail = node.inputs?.detail;
+  const connectionId = detail?.connectionId ?? "";
+  const connectionFolderKey = detail?.connectionFolderKey ?? "";
+  const values = model?.bindings?.values ?? [];
+  const connValue = values.find((v) => v.propertyAttribute === "ConnectionId");
+  const folderValue = values.find((v) => v.propertyAttribute === "FolderKey");
+  const connectionBinding = createBinding({
+    name: connValue?.name ?? "connection",
+    value: connectionId,
+    resource: "Connection",
+    resourceKey: connectionId,
+    propertyAttribute: "ConnectionId"
+  });
+  const folderKeyBinding = createBinding({
+    name: folderValue?.name ?? "FolderKey",
+    value: connectionFolderKey,
+    resource: "Connection",
+    resourceKey: connectionId,
+    propertyAttribute: "FolderKey"
+  });
+  return { connectionBinding, folderKeyBinding };
+}
+function resolveConnectorContextPlaceholders(context, storedConnection, storedFolderKey) {
+  if (!context)
+    return;
+  for (const entry of context) {
+    if (typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+      if (entry.name === "connection") {
+        entry.default = storedConnection.default;
+        entry.value = `=bindings.${storedConnection.id}`;
+      } else if (entry.name === "folderKey") {
+        entry.default = storedFolderKey.default;
+        entry.value = `=bindings.${storedFolderKey.id}`;
+      }
+    }
+  }
+}
 function ensureProcessBindings(workflow, logger) {
   const nodes = workflow.nodes ?? [];
   const definitions = workflow.definitions ?? [];
   let bindingsCreated = 0;
   for (const node of nodes) {
-    if (!isProcessNode(node.type))
-      continue;
     const nodeModel = node.model;
     const defModel = definitions.find((d) => d.nodeType === node.type)?.model;
     const hasUnresolved = [nodeModel, defModel].some((m) => m?.context?.some((entry) => typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)));
@@ -240,25 +281,49 @@ function ensureProcessBindings(workflow, logger) {
     const definition = definitions.find((d) => d.nodeType === node.type);
     if (!definition)
       continue;
-    let nameBinding;
-    let folderBinding;
-    try {
-      ({ nameBinding, folderBinding } = createProcessBindings(definition));
-    } catch (err) {
-      logger.warn(`Skipping binding resolution for node "${node.id}": ${err instanceof Error ? err.message : String(err)}`);
+    if (isProcessNode(node.type)) {
+      let nameBinding;
+      let folderBinding;
+      try {
+        ({ nameBinding, folderBinding } = createProcessBindings(definition));
+      } catch (err) {
+        logger.warn(`Skipping binding resolution for node "${node.id}": ${err instanceof Error ? err.message : String(err)}`);
+        continue;
+      }
+      const beforeCount = workflow.bindings?.length ?? 0;
+      addBinding(workflow, nameBinding);
+      addBinding(workflow, folderBinding);
+      const storedBindings = workflow.bindings;
+      const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+      const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+      resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
+      resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
+      const added = (workflow.bindings?.length ?? 0) - beforeCount;
+      bindingsCreated += added;
+      logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
       continue;
     }
-    const beforeCount = workflow.bindings?.length ?? 0;
-    addBinding(workflow, nameBinding);
-    addBinding(workflow, folderBinding);
-    const storedBindings = workflow.bindings;
-    const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
-    const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
-    resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
-    resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
-    const added = (workflow.bindings?.length ?? 0) - beforeCount;
-    bindingsCreated += added;
-    logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
+    if (isConnectorToolNode(node.type)) {
+      let connectionBinding;
+      let folderKeyBinding;
+      try {
+        ({ connectionBinding, folderKeyBinding } = createConnectorToolBindings(node, definition));
+      } catch (err) {
+        logger.warn(`Skipping connector binding resolution for node "${node.id}": ${err instanceof Error ? err.message : String(err)}`);
+        continue;
+      }
+      const beforeCount = workflow.bindings?.length ?? 0;
+      addBinding(workflow, connectionBinding);
+      addBinding(workflow, folderKeyBinding);
+      const storedBindings = workflow.bindings;
+      const storedConn = storedBindings.find((b) => b.resourceKey === connectionBinding.resourceKey && b.propertyAttribute === connectionBinding.propertyAttribute) ?? connectionBinding;
+      const storedFk = storedBindings.find((b) => b.resourceKey === folderKeyBinding.resourceKey && b.propertyAttribute === folderKeyBinding.propertyAttribute) ?? folderKeyBinding;
+      resolveConnectorContextPlaceholders(nodeModel?.context, storedConn, storedFk);
+      resolveConnectorContextPlaceholders(defModel?.context, storedConn, storedFk);
+      const added = (workflow.bindings?.length ?? 0) - beforeCount;
+      bindingsCreated += added;
+      logger.info(`Resolved connector bindings for node "${node.id}" (${node.type})`);
+    }
   }
   if (bindingsCreated > 0) {
     logger.info(`ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`);
@@ -641,4 +706,4 @@ export {
   FlowTool
 };
 
-//# debugId=7CD644DAD87726AA64756E2164756E21
+//# debugId=678C3E2292AA2F5364756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-flow",
-  "version": "1.197.0",
+  "version": "1.198.0-preview.100",
   "description": "UiPath Flow tool implementation",
   "type": "module",
   "exports": {
@@ -25,13 +25,13 @@
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@uipath/filesystem": "1.197.0",
+    "@uipath/filesystem": "1.198.0",
     "@uipath/flow-converter": "^0.8.2",
     "@uipath/flow-core": "^0.10.3",
     "@uipath/flow-migrations": "^0.8.0",
     "@uipath/flow-schema": "^0.10.3",
-    "@uipath/solutionpackager-tool-core": "1.197.0",
+    "@uipath/solutionpackager-tool-core": "1.198.0",
     "@uipath/tool-agent": "^2.0.0"
   },
-  "gitHead": "56f68b263cec4ea1f2a39d738bd99ecf52f88fea"
+  "gitHead": "f1942d52b26cbd5bae55fb2e1d28d4dea005100c"
 }

package/src/ensure-process-bindings.ts

@@ -13,12 +13,23 @@ const PROCESS_NODE_PREFIXES = [
     "uipath.core.api-workflow.",
 ];
 
-const UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+/**
+ * Node type prefix for IS connector tool nodes attached to inline agents.
+ * These use Connection-style bindings (ConnectionId + FolderKey) instead of
+ * process-style bindings (name + folderPath).
+ */
+const CONNECTOR_TOOL_PREFIX = "uipath.agent.resource.tool.connector.";
+
+const UNRESOLVED_BINDING_PATTERN = /^<bindings\.[^>]+>$/;
 
 function isProcessNode(nodeType: string): boolean {
     return PROCESS_NODE_PREFIXES.some((prefix) => nodeType?.startsWith(prefix));
 }
 
+function isConnectorToolNode(nodeType: string): boolean {
+    return nodeType?.startsWith(CONNECTOR_TOOL_PREFIX) ?? false;
+}
+
 function extractProcessGuid(nodeType: string): string {
     const match = nodeType.match(
         /^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i,
@@ -106,9 +117,88 @@ function resolveContextPlaceholders(
 }
 
 /**
- * Safety net: ensure every process/agent node in the workflow has corresponding
- * entries in the workflow `bindings` array and that `<bindings.*>` placeholders
- * in model.context are resolved to `=bindings.<id>` references.
+ * Create Connection bindings for an IS connector tool node.
+ * Reads binding names from the definition's model.bindings.values[]
+ * and defaults from the node's inputs.detail (connectionId, connectionFolderKey).
+ */
+function createConnectorToolBindings(
+    node: NodeInstance,
+    definition: { model?: Record<string, unknown> },
+): { connectionBinding: Binding; folderKeyBinding: Binding } {
+    const model = definition.model as
+        | {
+              bindings?: {
+                  resource?: string;
+                  resourceKey?: string;
+                  values?: Array<{
+                      name?: string;
+                      propertyAttribute?: string;
+                  }>;
+              };
+          }
+        | undefined;
+
+    const detail = (node.inputs as Record<string, unknown> | undefined)
+        ?.detail as Record<string, unknown> | undefined;
+    const connectionId = (detail?.connectionId as string) ?? "";
+    const connectionFolderKey = (detail?.connectionFolderKey as string) ?? "";
+
+    // Read binding names from manifest definition
+    const values = model?.bindings?.values ?? [];
+    const connValue = values.find(
+        (v) => v.propertyAttribute === "ConnectionId",
+    );
+    const folderValue = values.find((v) => v.propertyAttribute === "FolderKey");
+
+    const connectionBinding = createBinding({
+        name: connValue?.name ?? "connection",
+        value: connectionId,
+        resource: "Connection",
+        resourceKey: connectionId,
+        propertyAttribute: "ConnectionId",
+    });
+
+    const folderKeyBinding = createBinding({
+        name: folderValue?.name ?? "FolderKey",
+        value: connectionFolderKey,
+        resource: "Connection",
+        resourceKey: connectionId,
+        propertyAttribute: "FolderKey",
+    });
+
+    return { connectionBinding, folderKeyBinding };
+}
+
+/**
+ * Resolve <bindings.*> placeholders in model.context for connector tool nodes.
+ * Connector tools use "connection" and "folderKey" context entries.
+ */
+function resolveConnectorContextPlaceholders(
+    context: Array<Record<string, unknown>> | undefined,
+    storedConnection: Binding,
+    storedFolderKey: Binding,
+): void {
+    if (!context) return;
+    for (const entry of context) {
+        if (
+            typeof entry.value === "string" &&
+            UNRESOLVED_BINDING_PATTERN.test(entry.value)
+        ) {
+            if (entry.name === "connection") {
+                entry.default = storedConnection.default;
+                entry.value = `=bindings.${storedConnection.id}`;
+            } else if (entry.name === "folderKey") {
+                entry.default = storedFolderKey.default;
+                entry.value = `=bindings.${storedFolderKey.id}`;
+            }
+        }
+    }
+}
+
+/**
+ * Safety net: ensure every process/agent/connector-tool node in the workflow has
+ * corresponding entries in the workflow `bindings` array and that `<bindings.*>`
+ * placeholders in model.context are resolved to `=bindings.<id>` references.
  *
  * This handles flows authored outside the CLI (e.g. direct file edits or
  * skill-generated files) where `addNodeToFlow` was never called, so the
@@ -130,8 +220,6 @@ export function ensureProcessBindings(
     let bindingsCreated = 0;
 
     for (const node of nodes) {
-        if (!isProcessNode(node.type)) continue;
-
         const nodeModel = node.model as
             | { context?: Array<Record<string, unknown>> }
             | undefined;
@@ -151,56 +239,116 @@ export function ensureProcessBindings(
         const definition = definitions.find((d) => d.nodeType === node.type);
         if (!definition) continue;
 
-        let nameBinding: Binding;
-        let folderBinding: Binding;
-        try {
-            ({ nameBinding, folderBinding } =
-                createProcessBindings(definition));
-        } catch (err: unknown) {
-            logger.warn(
-                `Skipping binding resolution for node "${node.id}": ${err instanceof Error ? err.message : String(err)}`,
+        // --- Process-style nodes (RPA, agent, API workflow) ---
+        if (isProcessNode(node.type)) {
+            let nameBinding: Binding;
+            let folderBinding: Binding;
+            try {
+                ({ nameBinding, folderBinding } =
+                    createProcessBindings(definition));
+            } catch (err: unknown) {
+                logger.warn(
+                    `Skipping binding resolution for node "${node.id}": ${err instanceof Error ? err.message : String(err)}`,
+                );
+                continue;
+            }
+
+            const beforeCount =
+                (workflow.bindings as Binding[] | undefined)?.length ?? 0;
+            addBinding(workflow, nameBinding);
+            addBinding(workflow, folderBinding);
+
+            const storedBindings = workflow.bindings as Binding[];
+            const storedName =
+                storedBindings.find(
+                    (b) =>
+                        b.resourceKey === nameBinding.resourceKey &&
+                        b.propertyAttribute === nameBinding.propertyAttribute,
+                ) ?? nameBinding;
+            const storedFolder =
+                storedBindings.find(
+                    (b) =>
+                        b.resourceKey === folderBinding.resourceKey &&
+                        b.propertyAttribute === folderBinding.propertyAttribute,
+                ) ?? folderBinding;
+
+            resolveContextPlaceholders(
+                nodeModel?.context,
+                storedName,
+                storedFolder,
+            );
+            resolveContextPlaceholders(
+                defModel?.context,
+                storedName,
+                storedFolder,
+            );
+
+            const added =
+                ((workflow.bindings as Binding[] | undefined)?.length ?? 0) -
+                beforeCount;
+            bindingsCreated += added;
+
+            logger.info(
+                `Resolved process bindings for node "${node.id}" (${node.type})`,
             );
             continue;
         }
 
-        const beforeCount =
-            (workflow.bindings as Binding[] | undefined)?.length ?? 0;
-        addBinding(workflow, nameBinding);
-        addBinding(workflow, folderBinding);
-
-        // Resolve against stored bindings (addBinding deduplicates)
-        const storedBindings = workflow.bindings as Binding[];
-        const storedName =
-            storedBindings.find(
-                (b) =>
-                    b.resourceKey === nameBinding.resourceKey &&
-                    b.propertyAttribute === nameBinding.propertyAttribute,
-            ) ?? nameBinding;
-        const storedFolder =
-            storedBindings.find(
-                (b) =>
-                    b.resourceKey === folderBinding.resourceKey &&
-                    b.propertyAttribute === folderBinding.propertyAttribute,
-            ) ?? folderBinding;
-
-        // Resolve placeholders in node model.context
-        resolveContextPlaceholders(
-            nodeModel?.context,
-            storedName,
-            storedFolder,
-        );
+        // --- Connector tool nodes (IS activities as inline agent tools) ---
+        if (isConnectorToolNode(node.type)) {
+            let connectionBinding: Binding;
+            let folderKeyBinding: Binding;
+            try {
+                ({ connectionBinding, folderKeyBinding } =
+                    createConnectorToolBindings(node, definition));
+            } catch (err: unknown) {
+                logger.warn(
+                    `Skipping connector binding resolution for node "${node.id}": ${err instanceof Error ? err.message : String(err)}`,
+                );
+                continue;
+            }
 
-        // Resolve in definition model.context for BPMN converter
-        resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
+            const beforeCount =
+                (workflow.bindings as Binding[] | undefined)?.length ?? 0;
+            addBinding(workflow, connectionBinding);
+            addBinding(workflow, folderKeyBinding);
 
-        const added =
-            ((workflow.bindings as Binding[] | undefined)?.length ?? 0) -
-            beforeCount;
-        bindingsCreated += added;
+            const storedBindings = workflow.bindings as Binding[];
+            const storedConn =
+                storedBindings.find(
+                    (b) =>
+                        b.resourceKey === connectionBinding.resourceKey &&
+                        b.propertyAttribute ===
+                            connectionBinding.propertyAttribute,
+                ) ?? connectionBinding;
+            const storedFk =
+                storedBindings.find(
+                    (b) =>
+                        b.resourceKey === folderKeyBinding.resourceKey &&
+                        b.propertyAttribute ===
+                            folderKeyBinding.propertyAttribute,
+                ) ?? folderKeyBinding;
 
-        logger.info(
-            `Resolved process bindings for node "${node.id}" (${node.type})`,
-        );
+            resolveConnectorContextPlaceholders(
+                nodeModel?.context,
+                storedConn,
+                storedFk,
+            );
+            resolveConnectorContextPlaceholders(
+                defModel?.context,
+                storedConn,
+                storedFk,
+            );
+
+            const added =
+                ((workflow.bindings as Binding[] | undefined)?.length ?? 0) -
+                beforeCount;
+            bindingsCreated += added;
+
+            logger.info(
+                `Resolved connector bindings for node "${node.id}" (${node.type})`,
+            );
+        }
     }
 
     if (bindingsCreated > 0) {