@uipath/agent-tool 1.200.0-preview.120 → 1.201.0-preview.121

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

package/dist/{packager-tool-yet9qmnt.js → packager-tool-5xdkh3vm.js}

@@ -4,16 +4,16 @@ import {
 } from "./packager-tool-0gctz400.js";
 import {
   catchError
-} from "./packager-tool-jmzese1s.js";
+} from "./packager-tool-qa9gftnj.js";
 import {
   getFileSystem
-} from "./packager-tool-mf36zc9b.js";
+} from "./packager-tool-yv3rvyas.js";
 import {
   AUTH_FILENAME,
   DEFAULT_BASE_URL,
   DEFAULT_REDIRECT_URI,
   UIPATH_HOME_DIR
-} from "./packager-tool-1snc64g4.js";
+} from "./packager-tool-q42rrs00.js";
 import {
   __require
 } from "./packager-tool-wckvcay0.js";
@@ -913,6 +913,67 @@ var getTokenExpiration = (accessToken) => {
   }
 };
 
+// ../auth/src/sessionIdentity.ts
+var parseAuthFlow = (value) => value === "authorization_code" || value === "client_credentials" || value === "federated_credentials" ? value : undefined;
+var decodeClaims = (accessToken) => {
+  const [error, claims] = catchError(() => parseJWT(accessToken));
+  return error ? undefined : claims;
+};
+var asString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+var resolveIdentityType = (claims, authFlow, email) => {
+  const subType = asString(claims?.sub_type);
+  if (subType) {
+    return subType.startsWith("service") ? "Application" : "User";
+  }
+  if (authFlow) {
+    return authFlow === "authorization_code" ? "User" : "Application";
+  }
+  if (email)
+    return "User";
+  if (asString(claims?.client_id) && !asString(claims?.sub)) {
+    return "Application";
+  }
+  return;
+};
+var looksLikeEmail = (value) => value?.includes("@") ?? false;
+var pickEmail = (claims) => {
+  for (const candidate of [claims?.email, claims?.preferred_username]) {
+    const value = asString(candidate);
+    if (looksLikeEmail(value))
+      return value;
+  }
+  return;
+};
+var pickName = (claims) => {
+  const username = asString(claims?.preferred_username);
+  return asString(claims?.name) ?? (looksLikeEmail(username) ? undefined : username);
+};
+var resolveSessionIdentity = (accessToken, authFlow) => {
+  const claims = accessToken ? decodeClaims(accessToken) : undefined;
+  const email = pickEmail(claims);
+  const type = resolveIdentityType(claims, authFlow, email);
+  if (!type)
+    return;
+  const identity = { type };
+  if (authFlow)
+    identity.authFlow = authFlow;
+  if (type === "User") {
+    const userId = asString(claims?.sub);
+    if (userId)
+      identity.userId = userId;
+    if (email)
+      identity.userEmail = email;
+    const name = pickName(claims);
+    if (name)
+      identity.userName = name;
+    return identity;
+  }
+  const clientId = asString(claims?.client_id);
+  if (clientId)
+    identity.clientId = clientId;
+  return identity;
+};
+
 // ../auth/src/envAuth.ts
 var ENV_AUTH_ENABLE_VAR = "UIPATH_CLI_ENABLE_ENV_AUTH";
 var ENFORCE_ROBOT_AUTH_VAR = "UIPATH_CLI_ENFORCE_ROBOT_AUTH";
@@ -962,6 +1023,7 @@ var readAuthFromEnv = () => {
   }
   const expiration = getTokenExpiration(accessToken);
   const loginStatus = expiration && expiration <= new Date ? "Expired" : "Logged in";
+  const identity = resolveSessionIdentity(accessToken);
   return {
     loginStatus,
     accessToken,
@@ -971,7 +1033,8 @@ var readAuthFromEnv = () => {
     tenantName,
     tenantId,
     expiration,
-    source: "env" /* Env */
+    source: "env-vars" /* EnvironmentVariables */,
+    ...identity ? { identity } : {}
   };
 };
 
@@ -1225,6 +1288,9 @@ var refreshAccessToken = async ({
   return { accessToken: newAccessToken, refreshToken: newRefreshToken };
 };
 
+// ../auth/src/types.ts
+var AUTH_FLOW_ENV_VAR = "UIPATH_AUTH_FLOW";
+
 // ../auth/src/utils/envFile.ts
 var DEFAULT_AUTH_FILENAME = AUTH_FILENAME;
 var DEFAULT_ENV_FILENAME = `${UIPATH_HOME_DIR}/${AUTH_FILENAME}`;
@@ -1386,12 +1452,12 @@ var saveEnvFileAsync = async ({
 };
 
 // ../auth/src/loginStatus.ts
-var LoginStatusSource;
-((LoginStatusSource2) => {
-  LoginStatusSource2["File"] = "file";
-  LoginStatusSource2["Robot"] = "robot";
-  LoginStatusSource2["Env"] = "env";
-})(LoginStatusSource ||= {});
+var CredentialSource;
+((CredentialSource2) => {
+  CredentialSource2["SavedLogin"] = "saved-login";
+  CredentialSource2["Robot"] = "robot";
+  CredentialSource2["EnvironmentVariables"] = "env-vars";
+})(CredentialSource ||= {});
 var getLoginStatusAsync = async (options = {}) => {
   return getLoginStatusWithDeps(options);
 };
@@ -1597,7 +1663,8 @@ async function buildFileStatus(tokens, credentials, globalHint) {
     tenantName: credentials.UIPATH_TENANT_NAME,
     tenantId: credentials.UIPATH_TENANT_ID,
     expiration: tokens.expiration,
-    source: "file" /* File */,
+    source: "saved-login" /* SavedLogin */,
+    ...identityFields(tokens.accessToken, credentials),
     ...tokens.persistenceWarning ? { hint: tokens.persistenceWarning, persistenceFailed: true } : {},
     ...tokens.lockReleaseFailed ? { lockReleaseFailed: true } : {},
     ...tokens.tokenRefresh ? { tokenRefresh: tokens.tokenRefresh } : {}
@@ -1610,7 +1677,12 @@ async function buildFileStatus(tokens, credentials, globalHint) {
   }
   return result;
 }
+function identityFields(accessToken, credentials) {
+  const identity = resolveSessionIdentity(accessToken, parseAuthFlow(credentials[AUTH_FLOW_ENV_VAR]));
+  return identity ? { identity } : {};
+}
 function buildRobotStatus(robotCreds) {
+  const identity = resolveSessionIdentity(robotCreds.accessToken);
   return {
     loginStatus: "Logged in",
     accessToken: robotCreds.accessToken,
@@ -1621,7 +1693,8 @@ function buildRobotStatus(robotCreds) {
     tenantId: robotCreds.tenantId,
     issuer: robotCreds.issuer,
     expiration: getTokenExpiration(robotCreds.accessToken),
-    source: "robot" /* Robot */
+    source: "robot" /* Robot */,
+    ...identity ? { identity } : {}
   };
 }
 var isFileNotFoundError = (error) => {
@@ -1672,7 +1745,8 @@ async function circuitBreakerShortCircuit(ctx) {
       tenantName: credentials.UIPATH_TENANT_NAME,
       tenantId: credentials.UIPATH_TENANT_ID,
       expiration,
-      source: "file" /* File */
+      source: "saved-login" /* SavedLogin */,
+      ...identityFields(accessToken, credentials)
     } : {},
     hint: globalHint ?? (tokenIsDead ? deadHint : backoffHint),
     refreshCircuitOpen: true,
@@ -1694,7 +1768,8 @@ async function lockAcquireFailureStatus(ctx, error) {
       tenantName: ctx.credentials.UIPATH_TENANT_NAME,
       tenantId: ctx.credentials.UIPATH_TENANT_ID,
       expiration: ctx.expiration,
-      source: "file" /* File */,
+      source: "saved-login" /* SavedLogin */,
+      ...identityFields(ctx.accessToken, ctx.credentials),
       hint: globalHint,
       tokenRefresh: {
         attempted: false,
@@ -2088,6 +2163,16 @@ var federatedCredentialsLogin = async ({
   });
 };
 // ../auth/src/tenantSelection.ts
+var LOGIN_STATUS_HINT = "Run 'uip login status' to see the organization the CLI is signed in to.";
+var organizationHint = (organizationId) => `The request used '${organizationId}' as the organization. ${LOGIN_STATUS_HINT}`;
+var IDENTIFIER_STATUSES = new Set([400, 403, 404]);
+var describeNonJsonResponse = (organizationId, response, parseError) => {
+  if (response.redirected) {
+    return `Could not find organization '${organizationId}': the request was ` + `redirected to a sign-in page instead of the organization's tenant ` + `list. ${LOGIN_STATUS_HINT}`;
+  }
+  const contentType = response.headers.get("content-type") ?? "unknown";
+  return `The organization service returned a '${contentType}' response instead ` + `of JSON: ${parseError.message}. ${organizationHint(organizationId)}`;
+};
 var fetchTenantsAndOrganizations = async (baseUrl, accessToken, organizationId) => {
   const url = `${baseUrl}/${organizationId}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo`;
   const response = await fetch(url, {
@@ -2097,12 +2182,16 @@ var fetchTenantsAndOrganizations = async (baseUrl, accessToken, organizationId)
   });
   if (!response.ok) {
     if (response.status === 401) {
-      throw new Error("Unauthorized: Invalid or expired access token");
+      throw new Error(`Unauthorized: the access token was rejected, it was not ` + `issued for organization '${organizationId}', or ` + `'${organizationId}' was not accepted as an organization ` + `URL segment in this environment. ` + LOGIN_STATUS_HINT);
     }
     const errorText = await response.text();
-    throw new Error(`Failed to get tenants and organizations: ${response.status} ${errorText}`);
+    const message = `Failed to get tenants and organizations: ${response.status} ${errorText}`;
+    throw new Error(IDENTIFIER_STATUSES.has(response.status) ? `${message}. ${organizationHint(organizationId)}` : message);
+  }
+  const [parseError, data] = await catchError(response.json());
+  if (parseError) {
+    throw new Error(describeNonJsonResponse(organizationId, response, parseError));
   }
-  const data = await response.json();
   return data;
 };
 
@@ -2181,9 +2270,6 @@ var selectTenantWithDeps = async (baseUrl, accessToken, organizationId, targetTe
   return [selectedTenant.name, selectedTenant.id, organization.name];
 };
 
-// ../auth/src/types.ts
-var AUTH_FLOW_ENV_VAR = "UIPATH_AUTH_FLOW";
-
 // ../auth/src/interactive.ts
 var interactiveLoginWithDeps = async (options, deps) => {
   const {
@@ -2460,10 +2546,10 @@ var authenticate = async ({
   const authUrl = `${authorizationEndpoint}?${authParams.toString()}`;
   let strategy;
   if (isBrowser()) {
-    const { BrowserAuthStrategy } = await import("./browser-strategy-v4n9zxyf.js");
+    const { BrowserAuthStrategy } = await import("./browser-strategy-16yagjhr.js");
     strategy = new BrowserAuthStrategy;
   } else {
-    const { NodeAuthStrategy } = await import("./node-strategy-cvesesna.js");
+    const { NodeAuthStrategy } = await import("./node-strategy-1r3qegaf.js");
     strategy = new NodeAuthStrategy;
   }
   const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state, {
@@ -2482,6 +2568,6 @@ var authenticate = async ({
   });
 };
 
-export { setAuthFileConfig, InvalidBaseUrlError, DEFAULT_AUTH_PROFILE, AuthProfileValidationError, normalizeAuthProfileName, setActiveAuthProfile, clearActiveAuthProfile, getActiveAuthProfile, runWithAuthProfile, resolveAuthProfileFilePath, getActiveAuthProfileFilePath, parseJWT, ENV_AUTH_ENABLE_VAR, ENFORCE_ROBOT_AUTH_VAR, ENV_AUTH_VARS, EnvAuthConfigError, isEnvAuthEnabled, isRobotAuthEnforced, readAuthFromEnv, refreshTokenFingerprint, loadRefreshBreaker, saveRefreshBreaker, clearRefreshBreaker, registerRobotClientLoader, TokenRefreshOAuthError, isTokenRefreshOAuthFailure, refreshAccessToken, DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME, resolveEnvFileLocationAsync, resolveEnvFilePathAsync, loadEnvFileAsync, saveEnvFileAsync, LoginStatusSource, getLoginStatusAsync, getLoginStatusWithDeps, getAuthContext, getAuthEnv, ClientCredentialsAuthenticationError, clientCredentialsLogin, JWT_BEARER_ASSERTION_TYPE, FederatedCredentialsAuthenticationError, federatedCredentialsLogin, fetchTenantsAndOrganizations, TENANT_SELECTION_REQUIRED_CODE, INVALID_TENANT_CODE, TenantSelectionError, TenantSelectionRequiredError, InvalidTenantError, isTenantSelectionError, selectTenantWithDeps, AUTH_FLOW_ENV_VAR, interactiveLoginWithDeps, interactiveLogin, logoutWithDeps, logout, authenticate };
+export { setAuthFileConfig, InvalidBaseUrlError, DEFAULT_AUTH_PROFILE, AuthProfileValidationError, normalizeAuthProfileName, setActiveAuthProfile, clearActiveAuthProfile, getActiveAuthProfile, runWithAuthProfile, resolveAuthProfileFilePath, getActiveAuthProfileFilePath, parseJWT, parseAuthFlow, resolveSessionIdentity, ENV_AUTH_ENABLE_VAR, ENFORCE_ROBOT_AUTH_VAR, ENV_AUTH_VARS, EnvAuthConfigError, isEnvAuthEnabled, isRobotAuthEnforced, readAuthFromEnv, refreshTokenFingerprint, loadRefreshBreaker, saveRefreshBreaker, clearRefreshBreaker, registerRobotClientLoader, TokenRefreshOAuthError, isTokenRefreshOAuthFailure, refreshAccessToken, AUTH_FLOW_ENV_VAR, DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME, resolveEnvFileLocationAsync, resolveEnvFilePathAsync, loadEnvFileAsync, saveEnvFileAsync, CredentialSource, getLoginStatusAsync, getLoginStatusWithDeps, getAuthContext, getAuthEnv, ClientCredentialsAuthenticationError, clientCredentialsLogin, JWT_BEARER_ASSERTION_TYPE, FederatedCredentialsAuthenticationError, federatedCredentialsLogin, fetchTenantsAndOrganizations, TENANT_SELECTION_REQUIRED_CODE, INVALID_TENANT_CODE, TenantSelectionError, TenantSelectionRequiredError, InvalidTenantError, isTenantSelectionError, selectTenantWithDeps, interactiveLoginWithDeps, interactiveLogin, logoutWithDeps, logout, authenticate };
 
-//# debugId=A342771FA7DBDCE064756E2164756E21
+//# debugId=5D8E563B9619A42964756E2164756E21