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

package/dist/{agent-project-service-j3sst5cf.js → agent-project-service-wyh0r5cb.js}

@@ -1,9 +1,9 @@
 import {
   AgentProjectService
-} from "./packager-tool-fzq5y98q.js";
-import"./packager-tool-wfbw3w4y.js";
+} from "./packager-tool-ftfbnjpc.js";
+import"./packager-tool-hxd8e3e6.js";
 import"./packager-tool-nsrs2tm5.js";
-import"./packager-tool-mf36zc9b.js";
+import"./packager-tool-yv3rvyas.js";
 import"./packager-tool-wckvcay0.js";
 export {
   AgentProjectService

package/dist/agent-tool-OK5DK57D-mxt5stp9.js

@@ -0,0 +1,12 @@
+import {
+  AgentTool
+} from "./packager-tool-expj850v.js";
+import"./packager-tool-4fge2k9c.js";
+import"./packager-tool-zwztyzps.js";
+import"./packager-tool-b098y4a2.js";
+import"./packager-tool-wckvcay0.js";
+export {
+  AgentTool
+};
+
+//# debugId=0C17AF32789E0B7264756E2164756E21

package/dist/{browser-strategy-v4n9zxyf.js → browser-strategy-16yagjhr.js}

@@ -3,7 +3,7 @@ import {
 } from "./packager-tool-0gctz400.js";
 import {
   AUTH_CANCELLED_ERROR_CODE
-} from "./packager-tool-1snc64g4.js";
+} from "./packager-tool-q42rrs00.js";
 import"./packager-tool-wckvcay0.js";
 
 // ../auth/src/strategies/browser-strategy.ts

package/dist/executor-tool.js

@@ -0,0 +1,296 @@
+import {
+  AgentDebugCancelledError,
+  AgentDebugService
+} from "./packager-tool-rev4tnf6.js";
+import"./packager-tool-ftfbnjpc.js";
+import"./packager-tool-hxd8e3e6.js";
+import"./packager-tool-nsrs2tm5.js";
+import"./packager-tool-fz1pzt1z.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-yv3rvyas.js";
+import"./packager-tool-q42rrs00.js";
+import"./packager-tool-b098y4a2.js";
+import"./packager-tool-wckvcay0.js";
+// ../executor/project-executor/src/models/run-status.ts
+var TERMINAL_RUN_STATUSES = [
+  "Succeeded" /* Succeeded */,
+  "Faulted" /* Faulted */,
+  "Cancelled" /* Cancelled */
+];
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+var RAW_STATUS_MAP = {
+  completed: "Succeeded" /* Succeeded */,
+  faulted: "Faulted" /* Faulted */,
+  cancelled: "Cancelled" /* Cancelled */,
+  canceled: "Cancelled" /* Cancelled */,
+  failed: "Faulted" /* Faulted */,
+  running: "Running" /* Running */,
+  inprogress: "Running" /* Running */,
+  pending: "Pending" /* Pending */,
+  successful: "Succeeded" /* Succeeded */,
+  stopped: "Cancelled" /* Cancelled */,
+  stopping: "Running" /* Running */,
+  suspended: "Suspended" /* Suspended */,
+  terminating: "Running" /* Running */,
+  new: "Pending" /* Pending */,
+  waitingforresource: "Pending" /* Pending */
+};
+function mapRunStatus(rawStatus) {
+  if (!rawStatus)
+    return "Unknown" /* Unknown */;
+  return RAW_STATUS_MAP[rawStatus.toLowerCase()] ?? "Unknown" /* Unknown */;
+}
+
+// ../executor/project-executor/src/models/run-result.ts
+class RunResult {
+  status;
+  errorCode;
+  rawStatus;
+  message;
+  jobKey;
+  instanceId;
+  runId;
+  traceId;
+  steps;
+  output;
+  url;
+  details;
+  constructor(status, errorCode = "None" /* None */, message) {
+    this.status = status;
+    this.errorCode = errorCode;
+    this.message = message;
+  }
+  get isSuccess() {
+    return this.status === "Succeeded" /* Succeeded */ && this.errorCode === "None" /* None */;
+  }
+  get isTerminal() {
+    return isTerminalRunStatus(this.status);
+  }
+  static succeeded(init = {}) {
+    return Object.assign(new RunResult("Succeeded" /* Succeeded */, "None" /* None */), init);
+  }
+  static failed(errorCode, message, init = {}) {
+    return Object.assign(new RunResult("Faulted" /* Faulted */, errorCode, message), init);
+  }
+}
+// ../executor/project-executor/src/services/executors-factory-repository.ts
+class ExecutorsFactoryRepository {
+  factoryMap = new Map;
+  onConflict;
+  constructor(onConflict) {
+    this.onConflict = onConflict ?? ((message) => console.warn(message));
+  }
+  registerProjectExecutorFactory(factory) {
+    for (const projectType of factory.supportedTypes) {
+      const existing = this.factoryMap.get(projectType);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          this.onConflict(`Executor factory conflict for project type '${projectType}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
+        continue;
+      }
+      this.factoryMap.set(projectType, factory);
+    }
+  }
+  canHandleProject(projectType) {
+    return this.factoryMap.has(projectType);
+  }
+  getProjectExecutorFactory(projectType) {
+    const factory = this.factoryMap.get(projectType);
+    if (!factory) {
+      throw new Error(`No executor is registered for project type '${projectType}'. ` + `Registered types: ${this.registeredTypes.join(", ") || "none"}.`);
+    }
+    return factory;
+  }
+  get registeredTypes() {
+    return [...this.factoryMap.keys()];
+  }
+  reset() {
+    this.factoryMap.clear();
+  }
+}
+var REGISTRY_KEY = Symbol.for("@uipath/project-executor/executorsFactoryRepository");
+var _global = globalThis;
+if (!_global[REGISTRY_KEY]) {
+  _global[REGISTRY_KEY] = new ExecutorsFactoryRepository;
+}
+var executorsFactoryRepository = _global[REGISTRY_KEY];
+
+// ../executor/project-executor/src/services/executor-factory-provider.ts
+var PROVIDER_KEY = Symbol.for("@uipath/project-executor/executorFactoryProvider");
+// ../executor/project-executor/src/services/project-executor.ts
+class ProjectExecutor {
+  fileSystem;
+  logger;
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  runAsync(_options, _cancellationToken) {
+    return Promise.resolve(RunResult.failed("UnsupportedProjectType" /* UnsupportedProjectType */, `${this.constructor.name} does not support run.`));
+  }
+  async resolveDefaultEntryPoint(projectPath) {
+    const entryPointsFile = this.fileSystem.path.join(projectPath, ENTRY_POINTS_FILE_NAME);
+    try {
+      const raw = await this.fileSystem.readFile(entryPointsFile, "utf-8");
+      if (!raw) {
+        return;
+      }
+      const declared = JSON.parse(raw).entryPoints;
+      return this.firstDeclaredEntryPoint(declared);
+    } catch (error) {
+      this.logger.warn(`Could not read the default entry point from ${entryPointsFile}: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+  }
+  asEntryPoint(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+  }
+  firstDeclaredEntryPoint(entryPoints) {
+    if (!Array.isArray(entryPoints)) {
+      return;
+    }
+    for (const entry of entryPoints) {
+      const filePath = this.asEntryPoint(entry?.filePath);
+      if (filePath) {
+        return filePath;
+      }
+    }
+    return;
+  }
+  dispose() {
+    return Promise.resolve();
+  }
+}
+var ENTRY_POINTS_FILE_NAME = "entry-points.json";
+// src/executor/agent-project-executor.ts
+var AGENT_ENTRY_POINT = "agent.json";
+var DEFAULT_POLL_INTERVAL_MS = 2000;
+var DEFAULT_TIMEOUT_MS = 600000;
+var defaultRunnerFactory = () => new AgentDebugService;
+
+class AgentProjectExecutor extends ProjectExecutor {
+  createRunner;
+  constructor(fileSystem, logger, createRunner = defaultRunnerFactory) {
+    super(fileSystem, logger);
+    this.createRunner = createRunner;
+  }
+  async runAsync(options, cancellationToken) {
+    const { project } = options;
+    if (!project.projectPath) {
+      return RunResult.failed("InvalidInput" /* InvalidInput */, "Running an agent requires the project directory.");
+    }
+    if (options.entryPoint && options.entryPoint !== AGENT_ENTRY_POINT) {
+      return RunResult.failed("InvalidInput" /* InvalidInput */, `An agent runs '${AGENT_ENTRY_POINT}' and has no other entry point; got '${options.entryPoint}'.`);
+    }
+    const [authError, auth] = toDebugAuth(options);
+    if (authError) {
+      return RunResult.failed("Unauthorized" /* Unauthorized */, authError);
+    }
+    if (cancellationToken?.aborted) {
+      return RunResult.failed("Cancelled" /* Cancelled */, "Run cancelled before it started.");
+    }
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.logger.info(`Running agent '${project.name}' as a serverless debug job...`);
+    let outcome;
+    try {
+      outcome = await this.createRunner().debug({
+        projectPath: project.projectPath,
+        inputs: options.inputArguments ?? {},
+        pollIntervalMs,
+        maxPolls: maxPolls(options.timeoutMs, pollIntervalMs),
+        onState: (state) => options.callbacks?.onStatusChange?.(mapRunStatus(state)),
+        signal: cancellationToken
+      }, auth);
+    } catch (error) {
+      return this.toFailure(error, project.name);
+    }
+    return this.toRunResult(outcome);
+  }
+  resolveDefaultEntryPoint() {
+    return Promise.resolve(AGENT_ENTRY_POINT);
+  }
+  toFailure(error, projectName) {
+    if (error instanceof AgentDebugCancelledError) {
+      return RunResult.failed("Cancelled" /* Cancelled */, error.message, {
+        jobKey: error.jobKey
+      });
+    }
+    return RunResult.failed("StartFailed" /* StartFailed */, `Could not run agent '${projectName}': ${messageOf(error)}`, { details: { runnerError: messageOf(error) } });
+  }
+  toRunResult(outcome) {
+    const details = {
+      entryPoint: AGENT_ENTRY_POINT
+    };
+    if (outcome.info) {
+      details.info = outcome.info;
+    }
+    const common = {
+      jobKey: outcome.jobKey,
+      traceId: outcome.traceId,
+      rawStatus: outcome.finalState,
+      output: asOutputArguments(outcome.output),
+      details
+    };
+    if (!outcome.success) {
+      const result = RunResult.failed("ExecutionFailed" /* ExecutionFailed */, outcome.info ?? `The agent run ended ${outcome.finalState}.`, common);
+      result.status = mapRunStatus(outcome.finalState);
+      return result;
+    }
+    return RunResult.succeeded(common);
+  }
+}
+function toDebugAuth(options) {
+  const { baseUrl, accessToken, organizationId, tenantName } = options.connection;
+  const missing = [
+    ["base URL", baseUrl],
+    ["access token", accessToken],
+    ["organization", organizationId],
+    ["tenant name", tenantName]
+  ].filter(([, value]) => !value).map(([label]) => label);
+  if (missing.length > 0) {
+    return [
+      `Running an agent needs a signed-in session: the run is missing its ${missing.join(", ")}. Run 'uip login' first.`,
+      {}
+    ];
+  }
+  return [
+    undefined,
+    {
+      baseUrl,
+      accessToken,
+      organizationId,
+      tenantName
+    }
+  ];
+}
+function maxPolls(timeoutMs, pollIntervalMs) {
+  return Math.max(1, Math.ceil((timeoutMs ?? DEFAULT_TIMEOUT_MS) / pollIntervalMs));
+}
+function asOutputArguments(output) {
+  return output !== null && typeof output === "object" && !Array.isArray(output) ? output : undefined;
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/executor/agent-executor-factory.ts
+var AGENT_PROJECT_TYPES = ["Agent"];
+
+class AgentExecutorFactory {
+  supportedTypes = AGENT_PROJECT_TYPES;
+  createAsync(logger, fileSystem) {
+    return Promise.resolve(new AgentProjectExecutor(fileSystem, logger));
+  }
+}
+
+// src/executor-tool.ts
+var createExecutorFactory = () => new AgentExecutorFactory;
+export {
+  createExecutorFactory
+};
+
+//# debugId=492E5F05284574BE64756E2164756E21

package/dist/{index-b13x0rpx.js → index-3pq4x5b7.js}

@@ -2,6 +2,7 @@ import {
   AUTH_FLOW_ENV_VAR,
   AuthProfileValidationError,
   ClientCredentialsAuthenticationError,
+  CredentialSource,
   DEFAULT_AUTH_FILENAME,
   DEFAULT_AUTH_PROFILE,
   DEFAULT_ENV_FILENAME,
@@ -14,7 +15,6 @@ import {
   InvalidBaseUrlError,
   InvalidTenantError,
   JWT_BEARER_ASSERTION_TYPE,
-  LoginStatusSource,
   TENANT_SELECTION_REQUIRED_CODE,
   TenantSelectionError,
   TenantSelectionRequiredError,
@@ -42,6 +42,7 @@ import {
   logout,
   logoutWithDeps,
   normalizeAuthProfileName,
+  parseAuthFlow,
   parseJWT,
   readAuthFromEnv,
   refreshAccessToken,
@@ -50,25 +51,25 @@ import {
   resolveAuthProfileFilePath,
   resolveEnvFileLocationAsync,
   resolveEnvFilePathAsync,
+  resolveSessionIdentity,
   runWithAuthProfile,
   saveEnvFileAsync,
   saveRefreshBreaker,
   selectTenantWithDeps,
   setActiveAuthProfile,
   setAuthFileConfig
-} from "./packager-tool-yet9qmnt.js";
+} from "./packager-tool-fz1pzt1z.js";
 import {
   isBrowser,
   isNode
 } from "./packager-tool-0gctz400.js";
-import {
-  AUTH_TIMEOUT_ERROR_CODE
-} from "./packager-tool-jmzese1s.js";
-import"./packager-tool-mf36zc9b.js";
+import"./packager-tool-qa9gftnj.js";
+import"./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"./packager-tool-wckvcay0.js";
 export {
   setAuthFileConfig,
@@ -77,6 +78,7 @@ export {
   saveRefreshBreaker,
   saveEnvFileAsync,
   runWithAuthProfile,
+  resolveSessionIdentity,
   resolveEnvFilePathAsync,
   resolveEnvFileLocationAsync,
   resolveAuthProfileFilePath,
@@ -85,6 +87,7 @@ export {
   refreshAccessToken,
   readAuthFromEnv,
   parseJWT,
+  parseAuthFlow,
   normalizeAuthProfileName,
   logoutWithDeps,
   logout,
@@ -114,7 +117,6 @@ export {
   TenantSelectionRequiredError,
   TenantSelectionError,
   TENANT_SELECTION_REQUIRED_CODE,
-  LoginStatusSource,
   JWT_BEARER_ASSERTION_TYPE,
   InvalidTenantError,
   InvalidBaseUrlError,
@@ -128,6 +130,7 @@ export {
   DEFAULT_AUTH_TIMEOUT_MS,
   DEFAULT_AUTH_PROFILE,
   DEFAULT_AUTH_FILENAME,
+  CredentialSource,
   ClientCredentialsAuthenticationError,
   AuthProfileValidationError,
   AUTH_TIMEOUT_ERROR_CODE,
@@ -135,4 +138,4 @@ export {
   AUTH_CANCELLED_ERROR_CODE
 };
 
-//# debugId=FB6CD00532BDE8FA64756E2164756E21
+//# debugId=33F3EC28BA86732264756E2164756E21