@uipath/agent-tool 1.200.0-preview.109 → 1.201.0-preview.115

package/dist/{packager-tool-jmzese1s.js → node-strategy-1r3qegaf.js}

@@ -1,39 +1,18 @@
+import {
+  catchError
+} from "./packager-tool-qa9gftnj.js";
+import {
+  getFileSystem
+} from "./packager-tool-yv3rvyas.js";
 import {
   AUTH_CANCELLED_ERROR_CODE,
+  AUTH_TIMEOUT_ERROR_CODE,
   DEFAULT_AUTH_TIMEOUT_MS
-} from "./packager-tool-1snc64g4.js";
+} from "./packager-tool-q42rrs00.js";
 import {
   __require
 } from "./packager-tool-wckvcay0.js";
 
-// ../auth/src/catch-error.ts
-function isPromiseLike(value) {
-  return value !== null && typeof value === "object" && typeof value.then === "function";
-}
-function catchError(fnOrPromise) {
-  if (isPromiseLike(fnOrPromise)) {
-    return settlePromiseLike(fnOrPromise);
-  }
-  try {
-    const result = fnOrPromise();
-    if (isPromiseLike(result)) {
-      return settlePromiseLike(result);
-    }
-    return [undefined, result];
-  } catch (error) {
-    return [
-      error instanceof Error ? error : new Error(String(error)),
-      undefined
-    ];
-  }
-}
-function settlePromiseLike(thenable) {
-  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
-    error instanceof Error ? error : new Error(String(error)),
-    undefined
-  ]);
-}
-
 // ../auth/src/getBaseHtml.ts
 var escapeHtml = (value) => value.replace(/[&<>"']/g, (char) => {
   switch (char) {
@@ -198,7 +177,6 @@ var getBaseHtml = ({ title, message, type }) => {
 };
 
 // ../auth/src/server.ts
-var AUTH_TIMEOUT_ERROR_CODE = "EAUTHTIMEOUT";
 var startServer = async ({
   redirectUri,
   timeoutMs = DEFAULT_AUTH_TIMEOUT_MS,
@@ -315,6 +293,58 @@ var startServer = async ({
   });
 };
 
-export { catchError, AUTH_TIMEOUT_ERROR_CODE, startServer };
+// ../auth/src/strategies/node-strategy.ts
+class NodeAuthStrategy {
+  async execute(url, redirectUri, expectedState, opts) {
+    const fs = getFileSystem();
+    const callbackUrl = await startServer({
+      redirectUri,
+      timeoutMs: opts?.timeoutMs,
+      signal: opts?.signal,
+      onListening: async () => {
+        let safeUrl = "";
+        for (const ch of url) {
+          const c = ch.charCodeAt(0);
+          if (c > 31 && (c < 128 || c > 159))
+            safeUrl += ch;
+        }
+        if (opts?.noBrowser) {
+          if (!opts.onAuthUrl) {
+            throw new Error("Headless login (noBrowser) requires an onAuthUrl handler " + "to surface the authorize URL, but none was provided.");
+          }
+          opts.onAuthUrl(safeUrl);
+          return;
+        }
+        const [openError] = await catchError(fs.utils.open(url));
+        if (!openError)
+          return;
+        const isSpawnError = "code" in openError && openError.code === "ENOENT";
+        if (isSpawnError) {
+          throw new Error("Could not open a browser. No supported browser launcher was found. " + `On a headless or minimal system, use non-interactive login instead:
+
+` + `  uip login --client-id <id> --client-secret <secret> -t <tenant>
+
+` + "Or install a browser opener for your OS (e.g. xdg-utils on Linux).", { cause: openError });
+        }
+        throw new Error("Could not open the browser automatically. " + `Visit this URL to authenticate:
+
+  ${safeUrl}
+`, { cause: openError });
+      }
+    });
+    const returnedState = callbackUrl.searchParams.get("state");
+    if (returnedState !== expectedState) {
+      throw new Error("OAuth state mismatch — the callback state does not match the expected value. " + "This may indicate a CSRF attack. Please try signing in again.");
+    }
+    const code = callbackUrl.searchParams.get("code");
+    if (!code) {
+      throw new Error("No authorization code received");
+    }
+    return code;
+  }
+}
+export {
+  NodeAuthStrategy
+};
 
-//# debugId=5FADB965639A2C8E64756E2164756E21
+//# debugId=0F4DA8833B84D12264756E2164756E21

package/dist/packager-tool-4fge2k9c.js

@@ -0,0 +1,419 @@
+// ../../node_modules/@uipath/tool-agent/dist/chunk-UWHPEJIJ.js
+var BindingsConstants = {
+  ProcessResource: "process",
+  ConnectionResource: "connection",
+  IndexResource: "index",
+  McpResource: "mcpServer",
+  MemorySpaceResource: "memorySpace",
+  AppResource: "app",
+  AssetResource: "asset",
+  BucketResource: "bucket",
+  IxpResource: "ixp",
+  DataFabricEntityResource: "entity",
+  RemoteA2aAgentResource: "remoteA2aAgent",
+  VsEscalationType: 1,
+  BindingsModelVersion: "2.0",
+  BindingsValueNameKey: "name",
+  BindingsValueVersionKey: "version",
+  BindingsValueConnectionIdKey: "connectionId",
+  BindingsValueProcessNameDisplayName: "Process name",
+  BindingsValueConnectionIdDisplayName: "Connection ID",
+  BindingsValueByomConnectionIdDisplayName: "Model connection ID",
+  BindingsValueIndexNameDisplayName: "Index Name",
+  BindingsValueSlugDisplayName: "Slug",
+  BindingsValueMemoryNameDisplayName: "Memory name",
+  BindingsValueAppNameDisplayName: "App name",
+  BindingsValueAssetNameDisplayName: "Asset Name",
+  BindingsValueBucketNameDisplayName: "Storage Bucket Name",
+  BindingsValueIxpProjectNameDisplayName: "IXP project name",
+  BindingsValueIxpProjectVersionDisplayName: "IXP project version",
+  BindingsValueDataFabricEntityNameDisplayName: "Entity name",
+  BindingsValueFolderPathKey: "folderPath",
+  BindingsValueFolderPathDisplayName: "Folder path",
+  BindingsMetadataSubTypeKey: "subType",
+  BindingsMetadataConnectorKey: "connector",
+  BindingsMetadataUseConnectionServiceKey: "useConnectionService",
+  BindingsMetadataVersionKey: "bindingsVersion",
+  BindingsMetadataSolutionsSupport: "solutionsSupport",
+  BindingsMetadataAgentSubType: "agent",
+  BindingsMetadataProcessSubType: "process",
+  BindingsMetadataApiWorkflowSubType: "api",
+  BindingsMetadataAgenticProcessSubType: "processOrchestration",
+  BindingsMetadataFlowSubType: "flow",
+  BindingsMetadataFunctionSubType: "function",
+  BindingsMetadataVersion: "2.2",
+  BindingsMetadataTrue: "true"
+};
+var ASSET_RECIPIENT_TYPES = /* @__PURE__ */ new Set([4, 6]);
+var SOLUTION_FOLDER_SENTINEL = "solution_folder";
+function isAssetRecipientType(type) {
+  return ASSET_RECIPIENT_TYPES.has(type);
+}
+function createBindingValue(defaultValue, displayName) {
+  return { defaultValue, isExpression: false, displayName };
+}
+function defaultMetadata() {
+  return {
+    [BindingsConstants.BindingsMetadataVersionKey]: BindingsConstants.BindingsMetadataVersion,
+    [BindingsConstants.BindingsMetadataSolutionsSupport]: BindingsConstants.BindingsMetadataTrue
+  };
+}
+function resolveFolderPathBindingValue(raw) {
+  if (!raw || raw === SOLUTION_FOLDER_SENTINEL)
+    return;
+  return raw;
+}
+function addFolderPathToValue(value, raw) {
+  const resolved = resolveFolderPathBindingValue(raw);
+  if (resolved === undefined)
+    return;
+  value[BindingsConstants.BindingsValueFolderPathKey] = createBindingValue(resolved, BindingsConstants.BindingsValueFolderPathDisplayName);
+}
+function createProcessBinding(processName, subType, rawFolderPath) {
+  const value = {
+    [BindingsConstants.BindingsValueNameKey]: createBindingValue(processName, BindingsConstants.BindingsValueProcessNameDisplayName)
+  };
+  addFolderPathToValue(value, rawFolderPath);
+  return {
+    resource: BindingsConstants.ProcessResource,
+    key: processName,
+    value,
+    metadata: {
+      [BindingsConstants.BindingsMetadataSubTypeKey]: subType,
+      ...defaultMetadata()
+    }
+  };
+}
+function createConnectionBinding(connectionId, connectorKey, displayName) {
+  return {
+    resource: BindingsConstants.ConnectionResource,
+    key: connectionId,
+    value: {
+      [BindingsConstants.BindingsValueConnectionIdKey]: createBindingValue(connectionId, displayName)
+    },
+    metadata: {
+      [BindingsConstants.BindingsMetadataConnectorKey]: connectorKey,
+      [BindingsConstants.BindingsMetadataUseConnectionServiceKey]: BindingsConstants.BindingsMetadataTrue,
+      ...defaultMetadata()
+    }
+  };
+}
+function createIndexBinding(indexName, rawFolderPath) {
+  const value = {
+    [BindingsConstants.BindingsValueNameKey]: createBindingValue(indexName, BindingsConstants.BindingsValueIndexNameDisplayName)
+  };
+  addFolderPathToValue(value, rawFolderPath);
+  return {
+    resource: BindingsConstants.IndexResource,
+    key: indexName,
+    value,
+    metadata: defaultMetadata()
+  };
+}
+function createAppBinding(appName, rawFolderPath) {
+  const value = {
+    [BindingsConstants.BindingsValueNameKey]: createBindingValue(appName, BindingsConstants.BindingsValueAppNameDisplayName)
+  };
+  addFolderPathToValue(value, rawFolderPath);
+  return {
+    resource: BindingsConstants.AppResource,
+    key: appName,
+    value,
+    metadata: defaultMetadata()
+  };
+}
+function createAssetBinding(assetName, rawFolderPath) {
+  const value = {
+    [BindingsConstants.BindingsValueNameKey]: createBindingValue(assetName, BindingsConstants.BindingsValueAssetNameDisplayName)
+  };
+  addFolderPathToValue(value, rawFolderPath);
+  return {
+    resource: BindingsConstants.AssetResource,
+    key: assetName,
+    value,
+    metadata: defaultMetadata()
+  };
+}
+function createBucketBinding(bucketName, rawFolderPath) {
+  const value = {
+    [BindingsConstants.BindingsValueNameKey]: createBindingValue(bucketName, BindingsConstants.BindingsValueBucketNameDisplayName)
+  };
+  addFolderPathToValue(value, rawFolderPath);
+  return {
+    resource: BindingsConstants.BucketResource,
+    key: bucketName,
+    value,
+    metadata: defaultMetadata()
+  };
+}
+function generateAgentSettingsBindings(agent) {
+  if (agent.type !== "lowCode")
+    return [];
+  const byom = agent.settings.byomProperties;
+  if (!byom)
+    return [];
+  return [
+    createConnectionBinding(byom.connectionId, byom.connectorKey, BindingsConstants.BindingsValueByomConnectionIdDisplayName)
+  ];
+}
+function generateAgentGuardrailBindings(agent) {
+  if (agent.type !== "lowCode" || !agent.guardrails)
+    return [];
+  const bindings = [];
+  for (const guardrail of agent.guardrails) {
+    if (guardrail.action?.$actionType === "escalate") {
+      const { action } = guardrail;
+      const appName = action.app?.name;
+      if (appName) {
+        bindings.push(createAppBinding(appName, action.app?.folderName));
+      }
+      const recipient = action.recipient;
+      if (recipient && isAssetRecipientType(recipient.type) && "assetName" in recipient && recipient.assetName) {
+        bindings.push(createAssetBinding(recipient.assetName, "folderPath" in recipient ? recipient.folderPath : undefined));
+      }
+    }
+  }
+  return bindings;
+}
+function generateAgentBindings(agent) {
+  return [...generateAgentSettingsBindings(agent), ...generateAgentGuardrailBindings(agent)];
+}
+function generateFeatureBindings(feature) {
+  if (feature.$featureType === "memorySpace") {
+    const value = {
+      [BindingsConstants.BindingsValueNameKey]: createBindingValue(feature.memorySpaceName, BindingsConstants.BindingsValueMemoryNameDisplayName)
+    };
+    addFolderPathToValue(value, feature.folderPath);
+    return [
+      {
+        resource: BindingsConstants.MemorySpaceResource,
+        key: feature.memorySpaceName,
+        value,
+        metadata: defaultMetadata()
+      }
+    ];
+  }
+  return [];
+}
+function createProcessToolBinding(tool, subType) {
+  return [createProcessBinding(tool.properties.processName, subType, tool.properties.folderPath)];
+}
+function createIntegrationToolBindings(tool) {
+  return [
+    createConnectionBinding(tool.properties.connection.id, tool.properties.connection.connector.key, BindingsConstants.BindingsValueConnectionIdDisplayName)
+  ];
+}
+function createIxpToolBindings(tool) {
+  return [
+    {
+      resource: BindingsConstants.IxpResource,
+      key: tool.properties.projectName,
+      value: {
+        [BindingsConstants.BindingsValueNameKey]: createBindingValue(tool.properties.projectName, BindingsConstants.BindingsValueIxpProjectNameDisplayName),
+        [BindingsConstants.BindingsValueVersionKey]: createBindingValue(tool.properties.versionTag, BindingsConstants.BindingsValueIxpProjectVersionDisplayName)
+      },
+      metadata: {
+        [BindingsConstants.BindingsMetadataVersionKey]: BindingsConstants.BindingsMetadataVersion
+      }
+    }
+  ];
+}
+var DEFAULT_TOOL_BINDING_HANDLER_REGISTRY = {
+  process: (tool) => createProcessToolBinding(tool, BindingsConstants.BindingsMetadataProcessSubType),
+  agent: (tool) => createProcessToolBinding(tool, BindingsConstants.BindingsMetadataAgentSubType),
+  api: (tool) => createProcessToolBinding(tool, BindingsConstants.BindingsMetadataApiWorkflowSubType),
+  processOrchestration: (tool) => createProcessToolBinding(tool, BindingsConstants.BindingsMetadataAgenticProcessSubType),
+  flow: (tool) => createProcessToolBinding(tool, BindingsConstants.BindingsMetadataFlowSubType),
+  function: (tool) => createProcessToolBinding(tool, BindingsConstants.BindingsMetadataFunctionSubType),
+  integration: createIntegrationToolBindings,
+  ixp: createIxpToolBindings
+};
+function deepRagIndexName(tool) {
+  if (tool.type !== "internal")
+    return;
+  if (tool.properties.toolType !== "deep-rag")
+    return;
+  const { settings } = tool.properties;
+  if (!("indexName" in settings) || typeof settings.indexName !== "string" || settings.indexName.length === 0) {
+    return;
+  }
+  return settings.indexName;
+}
+function generateFallbackToolBindings(tool) {
+  const indexName = deepRagIndexName(tool);
+  if (indexName) {
+    return [createIndexBinding(indexName)];
+  }
+  return [];
+}
+function unhandledBindingsType(_value) {
+  return;
+}
+function resolveToolBindingsFromRegistry(tool, registry) {
+  switch (tool.type) {
+    case "process":
+      return registry.process?.(tool);
+    case "agent":
+      return registry.agent?.(tool);
+    case "api":
+      return registry.api?.(tool);
+    case "processOrchestration":
+      return registry.processOrchestration?.(tool);
+    case "flow":
+      return registry.flow?.(tool);
+    case "function":
+      return registry.function?.(tool);
+    case "integration":
+      return registry.integration?.(tool);
+    case "ixp":
+      return registry.ixp?.(tool);
+    case "internal":
+      return;
+    case "clientSide":
+      return registry.clientSide?.(tool);
+    default:
+      return unhandledBindingsType(tool);
+  }
+}
+function generateToolBindings(tool, registry = DEFAULT_TOOL_BINDING_HANDLER_REGISTRY) {
+  const bindings = resolveToolBindingsFromRegistry(tool, registry) ?? generateFallbackToolBindings(tool);
+  if (tool.guardrail?.policies) {
+    for (const policy of tool.guardrail.policies) {
+      if (policy.action?.$actionType === "escalate" && policy.action.app?.name) {
+        bindings.push(createAppBinding(policy.action.app.name, policy.action.app.folderName));
+      }
+    }
+  }
+  return bindings;
+}
+function generateDataFabricEntitySetBindings(context) {
+  if (context.entitySet.length === 0) {
+    return [];
+  }
+  return context.entitySet.map((entity) => {
+    const value = {
+      [BindingsConstants.BindingsValueNameKey]: createBindingValue(entity.name, BindingsConstants.BindingsValueDataFabricEntityNameDisplayName)
+    };
+    addFolderPathToValue(value, entity.folderId);
+    return {
+      resource: BindingsConstants.DataFabricEntityResource,
+      key: entity.referenceKey ?? entity.id,
+      value,
+      metadata: {
+        ...defaultMetadata(),
+        scope: "folder"
+      }
+    };
+  });
+}
+function generateContextBindings(context) {
+  if (context.contextType === "datafabricentityset") {
+    return generateDataFabricEntitySetBindings(context);
+  }
+  return [createIndexBinding(context.indexName, context.folderPath)];
+}
+function generateEscalationBindings(escalation) {
+  const bindings = [];
+  if (escalation.escalationType === BindingsConstants.VsEscalationType) {
+    const bucketName = escalation.vsEscalationProperties?.storageBucketName;
+    if (bucketName) {
+      bindings.push(createBucketBinding(bucketName, escalation.vsEscalationProperties?.storageBucketFolderPath));
+    }
+  } else {
+    for (const channel of escalation.channels ?? []) {
+      if (channel.type === "actionCenter") {
+        const appName = channel.properties?.appName;
+        if (appName) {
+          bindings.push(createAppBinding(appName, channel.properties?.folderName));
+        }
+      }
+      for (const recipient of channel.recipients ?? []) {
+        if (isAssetRecipientType(recipient.type) && "assetName" in recipient && recipient.assetName) {
+          bindings.push(createAssetBinding(recipient.assetName, "folderPath" in recipient ? recipient.folderPath : undefined));
+        }
+      }
+    }
+  }
+  return bindings;
+}
+function generateMcpBindings(mcp) {
+  const value = {
+    [BindingsConstants.BindingsValueNameKey]: createBindingValue(mcp.slug, BindingsConstants.BindingsValueSlugDisplayName)
+  };
+  addFolderPathToValue(value, mcp.folderPath);
+  return [
+    {
+      resource: BindingsConstants.McpResource,
+      key: mcp.slug,
+      value,
+      metadata: defaultMetadata()
+    }
+  ];
+}
+function generateA2aBindings(a2a) {
+  const value = {
+    [BindingsConstants.BindingsValueNameKey]: createBindingValue(a2a.slug, BindingsConstants.BindingsValueSlugDisplayName)
+  };
+  addFolderPathToValue(value, a2a.folderPath);
+  return [
+    {
+      resource: BindingsConstants.RemoteA2aAgentResource,
+      key: a2a.slug,
+      value,
+      metadata: defaultMetadata()
+    }
+  ];
+}
+var DEFAULT_RESOURCE_BINDING_HANDLER_REGISTRY = {
+  tool: (resource) => generateToolBindings(resource),
+  context: (resource) => generateContextBindings(resource),
+  escalation: (resource) => generateEscalationBindings(resource),
+  mcp: (resource) => generateMcpBindings(resource),
+  a2a: (resource) => generateA2aBindings(resource)
+};
+function resolveResourceBindingsFromRegistry(resource, registry) {
+  switch (resource.$resourceType) {
+    case "tool":
+      return registry.tool?.(resource);
+    case "context":
+      return registry.context?.(resource);
+    case "escalation":
+      return registry.escalation?.(resource);
+    case "mcp":
+      return registry.mcp?.(resource);
+    case "a2a":
+      return registry.a2a?.(resource);
+    default:
+      return unhandledBindingsType(resource);
+  }
+}
+function generateResourceBindings(resource, registry = DEFAULT_RESOURCE_BINDING_HANDLER_REGISTRY) {
+  return resolveResourceBindingsFromRegistry(resource, registry) ?? [];
+}
+function generateBindings(agent, resources, features) {
+  const allBindings = [];
+  for (const resource of resources) {
+    allBindings.push(...generateResourceBindings(resource));
+  }
+  for (const feature of features) {
+    allBindings.push(...generateFeatureBindings(feature));
+  }
+  allBindings.push(...generateAgentBindings(agent));
+  const seen = /* @__PURE__ */ new Set;
+  const uniqueBindings = [];
+  for (const binding of allBindings) {
+    const key = `${binding.resource}_${binding.key}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueBindings.push(binding);
+    }
+  }
+  return {
+    version: BindingsConstants.BindingsModelVersion,
+    resources: uniqueBindings
+  };
+}
+
+export { generateBindings };
+
+//# debugId=45E9220E0E4BB6ED64756E2164756E21