@uipath/agent-tool 1.197.0-preview.65 → 1.197.0-preview.66

package/dist/tool.js

@@ -8080,11 +8080,234 @@ var init_output_format_context = __esm(() => {
   filterSlot = singleton("OutputFilter");
 });
 
+// ../common/src/telemetry/command-terminal.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function stringField(value, field) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const raw = value[field];
+  return typeof raw === "string" ? raw : undefined;
+}
+function numberField(value, field) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const raw = value[field];
+  return typeof raw === "number" ? raw : undefined;
+}
+function findStringInCauseChain(error, field) {
+  let current = error;
+  for (let depth = 0;depth < 5 && current !== null && typeof current === "object"; depth++) {
+    const value = stringField(current, field);
+    if (value) {
+      return value;
+    }
+    current = current.cause;
+  }
+  return;
+}
+function findCodeInCauseChain(error) {
+  return findStringInCauseChain(error, "code");
+}
+function isSpawnEnoent(error) {
+  const code = findCodeInCauseChain(error);
+  if (code !== "ENOENT") {
+    return false;
+  }
+  const syscall = findStringInCauseChain(error, "syscall");
+  return syscall?.startsWith("spawn") === true;
+}
+function isCancellationError(error, exitCode, pollSignal) {
+  if (exitCode === 130) {
+    return true;
+  }
+  if (!isRecord(error)) {
+    return false;
+  }
+  if (numberField(error, "exitCode") === 130) {
+    return true;
+  }
+  const name = stringField(error, "name");
+  if (name === "ExitPromptError") {
+    return true;
+  }
+  if (name === "AbortError" && pollSignal?.aborted) {
+    return true;
+  }
+  const message = stringField(error, "message");
+  return message?.includes("SIGINT") === true;
+}
+function terminalSignalFor(input, outcome) {
+  if (input.recordedFailure?.terminalSignal) {
+    return input.recordedFailure.terminalSignal;
+  }
+  const explicit = findStringInCauseChain(input.error, "terminalSignal") ?? findStringInCauseChain(input.error, "signal");
+  if (explicit) {
+    return explicit;
+  }
+  return outcome === "cancelled" ? "SIGINT" : undefined;
+}
+function classifyHttpStatus(status) {
+  if (status === 401 || status === 403) {
+    return "auth";
+  }
+  if (status === 400 || status === 409 || status === 422) {
+    return "validation";
+  }
+  if (status === 408) {
+    return "timeout";
+  }
+  return "network_http";
+}
+function classifyFromResult(result) {
+  switch (result) {
+    case "AuthenticationError":
+      return "auth";
+    case "ValidationError":
+      return "validation";
+    case "TimeoutError":
+      return "timeout";
+    default:
+      return;
+  }
+}
+function classifyFromErrorCode(errorCode) {
+  if (!errorCode) {
+    return;
+  }
+  if (AUTH_ERROR_CODES.has(errorCode)) {
+    return "auth";
+  }
+  if (VALIDATION_ERROR_CODES.has(errorCode)) {
+    return "validation";
+  }
+  if (TIMEOUT_ERROR_CODES.has(errorCode)) {
+    return "timeout";
+  }
+  if (NETWORK_HTTP_ERROR_CODES.has(errorCode)) {
+    return "network_http";
+  }
+  return;
+}
+function classifyFromError(error) {
+  const code = findCodeInCauseChain(error);
+  if (code) {
+    if (code.startsWith("commander.")) {
+      return "validation";
+    }
+    if (NETWORK_OS_ERROR_CODES.has(code) || TLS_ERROR_CODES2.has(code)) {
+      return "network_http";
+    }
+    if (TIMEOUT_OS_ERROR_CODES.has(code)) {
+      return "timeout";
+    }
+    if (MISSING_DEPENDENCY_CODES.has(code) || isSpawnEnoent(error)) {
+      return "missing_dependency";
+    }
+  }
+  const message = stringField(error, "message");
+  if (message?.includes("fetch failed") === true) {
+    return "network_http";
+  }
+  const name = stringField(error, "name");
+  if (name && INTERNAL_ERROR_NAMES.has(name)) {
+    return "internal";
+  }
+  return;
+}
+function classifyError(input) {
+  const recorded = input.recordedFailure;
+  if (recorded?.errorClass) {
+    return recorded.errorClass;
+  }
+  const status = recorded?.context?.httpStatus;
+  if (status !== undefined) {
+    return classifyHttpStatus(status);
+  }
+  return classifyFromResult(recorded?.result) ?? classifyFromErrorCode(recorded?.errorCode) ?? classifyFromError(input.error) ?? "unknown";
+}
+function recordCommandFailureTelemetry(failure) {
+  recordedFailureSlot.set(failure);
+}
+function clearRecordedCommandFailureTelemetry() {
+  recordedFailureSlot.clear();
+}
+function takeRecordedCommandFailureTelemetry() {
+  const failure = recordedFailureSlot.get();
+  recordedFailureSlot.clear();
+  return failure;
+}
+function buildCommandTerminalTelemetryProperties(input) {
+  const cancelled = isCancellationError(input.error, input.exitCode, input.pollSignal);
+  const outcome = input.recordedFailure?.terminalOutcome ?? (input.exitCode === 0 ? "success" : cancelled ? "cancelled" : "failure");
+  const errorClass = outcome === "success" || outcome === "no_op" ? undefined : outcome === "cancelled" ? "user_cancelled" : classifyError(input);
+  const terminalSignal = terminalSignalFor(input, outcome);
+  return {
+    exit_code: input.exitCode,
+    terminal_outcome: outcome,
+    ...errorClass ? { error_class: errorClass } : {},
+    ...terminalSignal ? { terminal_signal: terminalSignal } : {}
+  };
+}
+var recordedFailureSlot, AUTH_ERROR_CODES, VALIDATION_ERROR_CODES, NETWORK_HTTP_ERROR_CODES, TIMEOUT_ERROR_CODES, NETWORK_OS_ERROR_CODES, TIMEOUT_OS_ERROR_CODES, TLS_ERROR_CODES2, MISSING_DEPENDENCY_CODES, INTERNAL_ERROR_NAMES;
+var init_command_terminal = __esm(() => {
+  init_singleton();
+  recordedFailureSlot = singleton("CommandTelemetryFailure");
+  AUTH_ERROR_CODES = new Set([
+    "authentication_required",
+    "permission_denied"
+  ]);
+  VALIDATION_ERROR_CODES = new Set(["invalid_argument"]);
+  NETWORK_HTTP_ERROR_CODES = new Set([
+    "network_error",
+    "rate_limited",
+    "server_error",
+    "not_found",
+    "method_not_allowed"
+  ]);
+  TIMEOUT_ERROR_CODES = new Set(["timeout"]);
+  NETWORK_OS_ERROR_CODES = new Set([
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EAI_FAIL"
+  ]);
+  TIMEOUT_OS_ERROR_CODES = new Set(["ETIMEDOUT", "ESOCKETTIMEDOUT"]);
+  TLS_ERROR_CODES2 = new Set([
+    "SELF_SIGNED_CERT_IN_CHAIN",
+    "DEPTH_ZERO_SELF_SIGNED_CERT",
+    "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+    "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+    "UNABLE_TO_GET_ISSUER_CERT",
+    "CERT_HAS_EXPIRED",
+    "CERT_UNTRUSTED",
+    "ERR_TLS_CERT_ALTNAME_INVALID"
+  ]);
+  MISSING_DEPENDENCY_CODES = new Set([
+    "MODULE_NOT_FOUND",
+    "ERR_MODULE_NOT_FOUND"
+  ]);
+  INTERNAL_ERROR_NAMES = new Set([
+    "TypeError",
+    "ReferenceError",
+    "SyntaxError",
+    "RangeError"
+  ]);
+});
+
 // ../common/src/telemetry/telemetry-events.ts
 var CommonTelemetryEvents;
 var init_telemetry_events = __esm(() => {
   CommonTelemetryEvents = {
-    Error: "uip.error"
+    Error: "uip.error",
+    ShipSucceeded: "ship_succeeded"
   };
 });
 
@@ -8164,7 +8387,146 @@ var init_debug_telemetry_provider = __esm(() => {
 });
 
 // ../common/src/telemetry/detect-agent.ts
-var init_detect_agent = () => {};
+function detectAgentFromEnv(env) {
+  for (const agent of KNOWN_AGENTS) {
+    const envValue = env[agent.envVar];
+    if (agent.value !== undefined) {
+      if (envValue === agent.value)
+        return agent.id;
+    } else {
+      if (envValue)
+        return agent.id;
+    }
+  }
+  const agentEnv = env.AGENT;
+  if (agentEnv) {
+    if (agentEnv === "1" || agentEnv === "true")
+      return "unknown";
+    if (agentEnv.length <= 32)
+      return agentEnv.toLowerCase();
+  }
+  return;
+}
+var KNOWN_AGENTS;
+var init_detect_agent = __esm(() => {
+  KNOWN_AGENTS = [
+    { envVar: "CLAUDECODE", value: "1", id: "claude-code" },
+    { envVar: "CURSOR_AGENT", value: "1", id: "cursor" },
+    { envVar: "GEMINI_CLI", value: "1", id: "gemini-cli" },
+    { envVar: "CODEX_THREAD_ID", id: "codex" },
+    { envVar: "CODEX_SANDBOX", id: "codex" },
+    { envVar: "AUGMENT_AGENT", value: "1", id: "augment" },
+    { envVar: "CLINE_ACTIVE", value: "true", id: "cline" }
+  ];
+});
+
+// ../common/src/telemetry/environment-info.ts
+var LOCAL_HOSTS;
+var init_environment_info = __esm(() => {
+  LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+});
+
+// ../common/src/telemetry/execution-context.ts
+function currentEnv() {
+  return typeof process === "undefined" ? {} : process.env;
+}
+function currentTtyState() {
+  if (typeof process === "undefined")
+    return false;
+  return Boolean(process.stdout?.isTTY || process.stdin?.isTTY || process.stderr?.isTTY);
+}
+function detectCi(env) {
+  const signature = CI_SIGNATURES.find((candidate) => candidate.matches(env));
+  if (!signature)
+    return;
+  return {
+    executionContext: signature.isScheduler?.(env) ? "scheduler" : "ci",
+    ciProvider: signature.provider
+  };
+}
+function detectExecutionContext(options = {}) {
+  const env = options.env ?? currentEnv();
+  const ci = detectCi(env);
+  if (ci)
+    return ci;
+  const agent = options.agent ?? detectAgentFromEnv(env);
+  if (agent) {
+    return { executionContext: "agent" };
+  }
+  const authSignal = options.authSignal ?? authSignalSlot.get();
+  if (authSignal === "service_account") {
+    return { executionContext: "service_account" };
+  }
+  const isTty = options.isTty ?? currentTtyState();
+  if (isTty) {
+    return { executionContext: "manual" };
+  }
+  return { executionContext: "unknown" };
+}
+function getExecutionContextTelemetryProperties() {
+  const detected = detectExecutionContext();
+  return {
+    execution_context: detected.executionContext,
+    ...detected.ciProvider ? { ci_provider: detected.ciProvider } : {}
+  };
+}
+var authSignalSlot, isTruthy = (value) => value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false", isEqual = (value, expected) => value?.toLowerCase() === expected, CI_SIGNATURES;
+var init_execution_context = __esm(() => {
+  init_singleton();
+  init_detect_agent();
+  authSignalSlot = singleton("TelemetryExecutionContextAuthSignal");
+  CI_SIGNATURES = [
+    {
+      provider: "github_actions",
+      matches: (env) => isTruthy(env.GITHUB_ACTIONS),
+      isScheduler: (env) => env.GITHUB_EVENT_NAME === "schedule"
+    },
+    {
+      provider: "azure_devops",
+      matches: (env) => isTruthy(env.TF_BUILD),
+      isScheduler: (env) => isEqual(env.BUILD_REASON, "schedule")
+    },
+    {
+      provider: "gitlab",
+      matches: (env) => isTruthy(env.GITLAB_CI),
+      isScheduler: (env) => env.CI_PIPELINE_SOURCE === "schedule"
+    },
+    {
+      provider: "circleci",
+      matches: (env) => isTruthy(env.CIRCLECI),
+      isScheduler: (env) => env.CIRCLE_PIPELINE_TRIGGER_SOURCE === "scheduled_pipeline"
+    },
+    {
+      provider: "jenkins",
+      matches: (env) => isTruthy(env.JENKINS_URL) || isTruthy(env.JENKINS_HOME)
+    },
+    {
+      provider: "teamcity",
+      matches: (env) => isTruthy(env.TEAMCITY_VERSION)
+    },
+    {
+      provider: "buildkite",
+      matches: (env) => isTruthy(env.BUILDKITE),
+      isScheduler: (env) => env.BUILDKITE_SOURCE === "schedule"
+    },
+    {
+      provider: "bitbucket",
+      matches: (env) => isTruthy(env.BITBUCKET_BUILD_NUMBER)
+    },
+    {
+      provider: "travis",
+      matches: (env) => isTruthy(env.TRAVIS)
+    },
+    {
+      provider: "appveyor",
+      matches: (env) => isTruthy(env.APPVEYOR)
+    },
+    {
+      provider: "generic",
+      matches: (env) => isTruthy(env.CI)
+    }
+  ];
+});
 
 // ../common/src/telemetry/node-context-storage.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -8180,6 +8542,29 @@ class NodeContextStorage {
 }
 var init_node_context_storage = () => {};
 
+// ../common/src/telemetry/session-id.ts
+function getProcessEnv() {
+  return globalThis.process?.env;
+}
+function normalizeSessionId(value) {
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return;
+  }
+  const trimmed = String(value).trim();
+  return trimmed || undefined;
+}
+function getConfiguredTelemetrySessionId() {
+  return normalizeSessionId(getProcessEnv()?.[TELEMETRY_SESSION_ID_ENV]);
+}
+function resolveTelemetrySessionId(existingSessionId) {
+  return getConfiguredTelemetrySessionId() ?? normalizeSessionId(existingSessionId);
+}
+var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID", TELEMETRY_SESSION_ID_PROPERTY = "session_id", telemetrySessionIdSlot;
+var init_session_id = __esm(() => {
+  init_singleton();
+  telemetrySessionIdSlot = singleton("TelemetrySessionId");
+});
+
 // ../common/src/telemetry/global-telemetry-properties.ts
 function getGlobalTelemetryProperties() {
   return telemetryPropsSlot.get();
@@ -8268,26 +8653,41 @@ class TelemetryService {
     return this.contextStorage.getContext();
   }
   enrichPropertiesWithContext(properties, context) {
-    return {
-      ...getGlobalTelemetryProperties(),
+    const globalProperties = getGlobalTelemetryProperties();
+    const existingSessionId = properties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? this.defaultProperties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? globalProperties?.[TELEMETRY_SESSION_ID_PROPERTY];
+    const sessionId = resolveTelemetrySessionId(existingSessionId);
+    const enriched = {
+      ...getExecutionContextTelemetryProperties(),
+      ...globalProperties,
       ...this.defaultProperties,
       ...properties,
       ...context
     };
+    if (sessionId === undefined) {
+      delete enriched[TELEMETRY_SESSION_ID_PROPERTY];
+    } else {
+      enriched[TELEMETRY_SESSION_ID_PROPERTY] = sessionId;
+    }
+    return enriched;
   }
   generateId() {
     return crypto.randomUUID().replaceAll("-", "");
   }
 }
 var init_telemetry_service = __esm(() => {
+  init_execution_context();
   init_global_telemetry_properties();
+  init_session_id();
 });
 
 // ../common/src/telemetry/node.ts
 var init_node2 = __esm(() => {
   init_debug_telemetry_provider();
   init_detect_agent();
+  init_environment_info();
+  init_execution_context();
   init_node_context_storage();
+  init_session_id();
   init_telemetry_service();
 });
 
@@ -8297,6 +8697,7 @@ var init_node_appinsights_telemetry_provider = __esm(() => {
   init_logger();
   init_singleton();
   init_global_telemetry_properties();
+  init_session_id();
   init_global_telemetry_properties();
   providerSlot = singleton("TelemetryProvider");
 });
@@ -8702,6 +9103,7 @@ var init_formatter = __esm(() => {
   init_logger();
   init_output_context();
   init_output_format_context();
+  init_command_terminal();
   init_telemetry_events();
   init_telemetry_init();
   CLI_ERROR_CODES = [
@@ -8776,8 +9178,24 @@ var init_formatter = __esm(() => {
       data.ErrorCode ??= defaultErrorCodeForFailure(data);
       data.Retry ??= defaultRetryForErrorCode(data.ErrorCode);
       process.exitCode = EXIT_CODES[data.Result] ?? 1;
-      const { SuppressTelemetry, ...envelope } = data;
-      if (!SuppressTelemetry) {
+      recordCommandFailureTelemetry({
+        result: data.Result,
+        errorCode: data.ErrorCode,
+        retry: data.Retry,
+        message: data.Message,
+        context: data.Context,
+        exitCode: process.exitCode,
+        errorClass: data.TelemetryErrorClass,
+        terminalOutcome: data.TelemetryTerminalOutcome,
+        terminalSignal: data.TelemetryTerminalSignal
+      });
+      const suppressTelemetry = data.SuppressTelemetry === true;
+      const envelope = { ...data };
+      delete envelope.SuppressTelemetry;
+      delete envelope.TelemetryErrorClass;
+      delete envelope.TelemetryTerminalOutcome;
+      delete envelope.TelemetryTerminalSignal;
+      if (!suppressTelemetry) {
         telemetry.trackEvent(CommonTelemetryEvents.Error, {
           result: data.Result,
           errorCode: data.ErrorCode,
@@ -8841,6 +9259,159 @@ var init_formatter = __esm(() => {
   })(OutputFormatter ||= {});
 });
 
+// ../common/src/telemetry/command-attribution.ts
+function productMode(productArea, mode) {
+  return { product_area: productArea, mode };
+}
+function attributionRecord(groups) {
+  const record = {};
+  for (const [productArea, mode, names] of groups) {
+    const attribution = productMode(productArea, mode);
+    for (const name of names) {
+      record[name] = attribution;
+    }
+  }
+  return record;
+}
+function commandAttribution(groups) {
+  const entries = [];
+  for (const [productArea, mode, prefixes] of groups) {
+    const attribution = productMode(productArea, mode);
+    for (const prefix of prefixes) {
+      entries.push({ prefix, attribution });
+    }
+  }
+  return entries;
+}
+function normalizeCommandPath(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) {
+    return;
+  }
+  const tokens = trimmed.includes(" ") ? trimmed.split(/\s+/).filter((token) => token.length > 0).filter((token) => !token.startsWith("-")) : trimmed.split(".").filter((token) => token.length > 0);
+  if (tokens.length === 0) {
+    return;
+  }
+  const commandTokens = tokens[0] === "uip" ? tokens : ["uip", ...tokens];
+  return commandTokens.join(".");
+}
+function getCommandProductModeAttribution(commandPath) {
+  const normalized = normalizeCommandPath(commandPath);
+  if (!normalized) {
+    return;
+  }
+  return COMMAND_ATTRIBUTION.find(({ prefix }) => normalized === prefix || normalized.startsWith(`${prefix}.`))?.attribution;
+}
+function normalizeSkillNameWithOptions(value, options) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return;
+  }
+  const hasLegacyNamespace = normalized.startsWith(LEGACY_SKILL_NAMESPACE);
+  if (hasLegacyNamespace && !options.allowLegacyNamespace) {
+    return;
+  }
+  const skillName = hasLegacyNamespace ? normalized.slice(LEGACY_SKILL_NAMESPACE.length) : normalized;
+  if (skillName.length > MAX_SKILL_NAME_LENGTH || !SKILL_NAME_PATTERN.test(skillName) || !KNOWN_SKILL_NAMES.has(skillName)) {
+    return;
+  }
+  return skillName;
+}
+function normalizeSkillName(value) {
+  return normalizeSkillNameWithOptions(value, {
+    allowLegacyNamespace: false
+  });
+}
+function buildCommandTelemetryAttribution(commandPath, skillSource) {
+  const skillName = normalizeSkillName(skillSource);
+  return {
+    ...skillName ? { skill_name: skillName } : {},
+    ...getCommandProductModeAttribution(commandPath)
+  };
+}
+var LEGACY_SKILL_NAMESPACE = "uipath:", MAX_SKILL_NAME_LENGTH = 80, SKILL_NAME_PATTERN, SKILL_ATTRIBUTION, KNOWN_SKILL_NAMES, COMMAND_ATTRIBUTION;
+var init_command_attribution = __esm(() => {
+  SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+  SKILL_ATTRIBUTION = attributionRecord([
+    ["admin", "operate", ["uipath-admin"]],
+    ["agents", "build", ["uipath-agents"]],
+    ["api-workflow", "build", ["uipath-api-workflow"]],
+    ["automation-discovery", "build", ["uipath-automation-discovery"]],
+    ["coded-apps", "build", ["uipath-coded-apps"]],
+    ["data-fabric", "operate", ["uipath-data-fabric"]],
+    ["cli", "troubleshoot", ["uipath-feedback"]],
+    ["governance", "operate", ["uipath-governance"]],
+    ["action-center", "build", ["uipath-human-in-the-loop"]],
+    ["document-understanding", "build", ["uipath-ixp"]],
+    [
+      "maestro",
+      "build",
+      ["uipath-maestro-bpmn", "uipath-maestro-case", "uipath-maestro-flow"]
+    ],
+    ["agenthub", "build", ["uipath-mcp-servers"]],
+    ["solution", "build", ["uipath-planner", "uipath-solution"]],
+    ["platform", "operate", ["uipath-platform"]],
+    ["quality", "troubleshoot", ["uipath-review"]],
+    ["rpa", "build", ["uipath-rpa"]],
+    ["cli", "operate", ["uipath-skill-catalog"]],
+    ["action-center", "operate", ["uipath-tasks"]],
+    ["test-manager", "operate", ["uipath-test"]],
+    ["platform", "troubleshoot", ["uipath-troubleshoot"]]
+  ]);
+  KNOWN_SKILL_NAMES = new Set(Object.keys(SKILL_ATTRIBUTION));
+  COMMAND_ATTRIBUTION = commandAttribution([
+    ["cli", "troubleshoot", ["uip.feedback"]],
+    ["llm-gateway", "operate", ["uip.llm-configuration", "uip.model-hub"]],
+    ["context-grounding", "build", ["uip.context-grounding"]],
+    ["api-workflow", "build", ["uip.api-workflow"]],
+    ["rpa", "build", ["uip.rpa-legacy"]],
+    ["conversational", "operate", ["uip.conversational"]],
+    ["agents", "build", ["uip.codedagent", "uip.agent"]],
+    ["agenthub", "build", ["uip.agenthub"]],
+    ["coded-apps", "build", ["uip.codedapp"]],
+    ["functions", "build", ["uip.functions"]],
+    ["solution", "build", ["uip.solution"]],
+    ["maestro", "build", ["uip.maestro", "uip.case", "uip.flow"]],
+    ["llm-observability", "troubleshoot", ["uip.traces"]],
+    ["platform", "operate", ["uip.platform"]],
+    ["admin", "operate", ["uip.admin"]],
+    ["automation-ops", "operate", ["uip.aops"]],
+    ["documentation", "troubleshoot", ["uip.docsai"]],
+    ["governance", "operate", ["uip.gov"]],
+    ["insights", "operate", ["uip.insights"]],
+    ["document-understanding", "build", ["uip.ixp"]],
+    ["process-mining", "operate", ["uip.pm"]],
+    ["action-center", "operate", ["uip.tasks"]],
+    ["test-manager", "operate", ["uip.tm"]],
+    ["vertical-solutions", "build", ["uip.vss"]],
+    ["data-fabric", "operate", ["uip.df"]],
+    ["integration-service", "build", ["uip.is"]],
+    ["orchestrator", "operate", ["uip.or"]],
+    [
+      "cli",
+      "operate",
+      [
+        "uip.login",
+        "uip.logout",
+        "uip.user",
+        "uip.config",
+        "uip.tools",
+        "uip.skills",
+        "uip.completion",
+        "uip.update",
+        "uip.mcp",
+        "uip.track"
+      ]
+    ]
+  ]).sort((a, b) => b.prefix.length - a.prefix.length);
+});
+
 // ../common/src/telemetry/pii-redactor.ts
 function shortHash(input) {
   let hash = 2166136261;
@@ -9016,12 +9587,20 @@ function commandHelpHint(commandPath) {
   const command = commandPath.replace(/\./g, " ");
   return `An unexpected error occurred. Run '${command} --help' to verify command syntax, or run with --log-level debug for details.`;
 }
+function isPromptCancellation(error) {
+  return error instanceof Error && error.name === "ExitPromptError";
+}
+function exitCodeFromProcess(fallback) {
+  return typeof process.exitCode === "number" ? process.exitCode : fallback;
+}
 var pollSignalSlot, cliErrorCodeValues, retryHintValues, processContext;
 var init_trackedAction = __esm(() => {
   init_esm();
   init_formatter();
   init_logger();
   init_singleton();
+  init_command_attribution();
+  init_command_terminal();
   init_pii_redactor();
   init_telemetry_init();
   pollSignalSlot = singleton("PollSignal");
@@ -9042,6 +9621,8 @@ var init_trackedAction = __esm(() => {
       const props = typeof properties === "function" ? properties(...args) : properties;
       const startTime = performance.now();
       let errorMessage;
+      let fallbackExitCode = EXIT_CODES.Success;
+      clearRecordedCommandFailureTelemetry();
       const [error] = await catchError(fn(...args));
       if (error) {
         errorMessage = error instanceof Error ? error.message : String(error);
@@ -9056,6 +9637,8 @@ var init_trackedAction = __esm(() => {
         const customRetry = isRetryHint(typedRetry) ? typedRetry : undefined;
         const typedContext = typed.context ?? typed.Context;
         const customContext = isErrorContext(typedContext) ? typedContext : undefined;
+        const cancellationExitCode = typed.exitCode === 130 || isPromptCancellation(error) ? 130 : undefined;
+        fallbackExitCode = cancellationExitCode ?? EXIT_CODES[finalResult];
         OutputFormatter.error({
           Result: finalResult,
           ...customErrorCode ? { ErrorCode: customErrorCode } : {},
@@ -9064,16 +9647,26 @@ var init_trackedAction = __esm(() => {
           ...customRetry ? { Retry: customRetry } : {},
           ...customContext ? { Context: customContext } : {}
         });
-        context.exit(EXIT_CODES[finalResult]);
+        context.exit(fallbackExitCode);
       }
       const durationMs = performance.now() - startTime;
-      const success = !error && (process.exitCode === undefined || process.exitCode === 0);
+      const exitCode = fallbackExitCode === 130 ? fallbackExitCode : exitCodeFromProcess(fallbackExitCode);
+      const recordedFailure = takeRecordedCommandFailureTelemetry();
+      const success = !error && exitCode === 0;
+      const terminalTelemetry = buildCommandTerminalTelemetryProperties({
+        error,
+        exitCode,
+        recordedFailure,
+        pollSignal: context.pollSignal
+      });
       telemetry.trackEvent(telemetryName, redactProperties({
         ...extractCommandParams(command),
         ...props,
+        ...buildCommandTelemetryAttribution(telemetryName, process.env.UIPATH_SKILL),
         command: "true",
         duration: String(durationMs),
         success: String(success),
+        ...terminalTelemetry,
         ...errorMessage ? { errorMessage } : {}
       }));
     });
@@ -9735,6 +10328,44 @@ var init_sdk_user_agent = __esm(() => {
   init_global_telemetry_properties();
   sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
 });
+// ../common/src/telemetry/ship-succeeded.ts
+function getShippedKeys() {
+  const existing = shippedKeysSlot.get();
+  if (existing) {
+    return existing;
+  }
+  const keys = new Set;
+  shippedKeysSlot.set(keys);
+  return keys;
+}
+function dedupeKey(payload) {
+  return [
+    payload.command_name,
+    payload.ship_kind,
+    payload.target,
+    payload.project_type,
+    payload.artifact_correlation_key ?? payload.package_version_key ?? payload.deployment_key ?? payload.solution_id ?? payload.package_name ?? ""
+  ].join("|");
+}
+function trackShipSucceeded(payload) {
+  const keys = getShippedKeys();
+  const key = dedupeKey(payload);
+  if (keys.has(key)) {
+    return false;
+  }
+  keys.add(key);
+  telemetry.trackEvent(CommonTelemetryEvents.ShipSucceeded, redactProperties({ ...payload }));
+  return true;
+}
+var shippedKeysSlot;
+var init_ship_succeeded = __esm(() => {
+  init_singleton();
+  init_pii_redactor();
+  init_telemetry_events();
+  init_telemetry_init();
+  shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
+});
+
 // ../common/src/tool-provider.ts
 var factorySlot;
 var init_tool_provider = __esm(() => {
@@ -9746,6 +10377,8 @@ var init_tool_provider = __esm(() => {
 var init_src2 = __esm(() => {
   init_console_guard();
   init_node_appinsights_telemetry_provider();
+  init_pii_redactor();
+  init_ship_succeeded();
   init_attachment_binding();
   init_command_examples();
   init_command_help();
@@ -9768,6 +10401,8 @@ var init_src2 = __esm(() => {
   init_screen_logger();
   init_sdk_user_agent();
   init_singleton();
+  init_command_attribution();
+  init_command_terminal();
   init_node2();
   init_telemetry_events();
   init_telemetry_init();
@@ -30457,6 +31092,9 @@ var init_selectTenant = __esm(() => {
   ]);
 });
 
+// ../auth/src/types.ts
+var AUTH_FLOW_ENV_VAR = "UIPATH_AUTH_FLOW";
+
 // ../auth/src/interactive.ts
 var interactiveLoginWithDeps = async (options, deps) => {
   const {
@@ -30506,6 +31144,7 @@ var interactiveLoginWithDeps = async (options, deps) => {
   if (noBrowser && !resolvedSecret && !onEvent) {
     throw new Error("noBrowser login requires an onEvent subscriber to receive the " + "auth-url event — the authorize URL is delivered through it.");
   }
+  const authFlow = resolvedSecret ? "client_credentials" : "authorization_code";
   const authPromise = resolvedSecret ? (async () => {
     return await clientCredentials({
       clientId: config.clientId,
@@ -30536,7 +31175,8 @@ var interactiveLoginWithDeps = async (options, deps) => {
   issuerAsserter(tokens.UIPATH_ACCESS_TOKEN, config.baseUrl);
   const credentials = {
     ...tokens,
-    UIPATH_URL: config.baseUrl
+    UIPATH_URL: config.baseUrl,
+    [AUTH_FLOW_ENV_VAR]: authFlow
   };
   try {
     const tokenData = jwtParser(tokens.UIPATH_ACCESS_TOKEN);
@@ -31130,7 +31770,8 @@ __export(exports_src2, {
   DEFAULT_AUTH_FILENAME: () => DEFAULT_AUTH_FILENAME,
   ClientCredentialsAuthenticationError: () => ClientCredentialsAuthenticationError,
   AuthProfileValidationError: () => AuthProfileValidationError,
-  AUTH_TIMEOUT_ERROR_CODE: () => AUTH_TIMEOUT_ERROR_CODE
+  AUTH_TIMEOUT_ERROR_CODE: () => AUTH_TIMEOUT_ERROR_CODE,
+  AUTH_FLOW_ENV_VAR: () => AUTH_FLOW_ENV_VAR
 });
 var authenticate = async ({
   baseUrl,
@@ -56457,7 +57098,7 @@ var init_package = __esm(() => {
   package_default5 = {
     name: "@uipath/integrationservice-sdk",
     license: "MIT",
-    version: "1.197.0-preview.65",
+    version: "1.197.0-preview.66",
     repository: {
       type: "git",
       url: "https://github.com/UiPath/cli.git",
@@ -80470,7 +81111,7 @@ import"./packager-tool.js";
 var package_default = {
   name: "@uipath/agent-tool",
   license: "MIT",
-  version: "1.197.0-preview.65",
+  version: "1.197.0-preview.66",
   description: "cli plugin for creating and managing UiPath low-code agents",
   private: false,
   repository: {
@@ -80645,7 +81286,7 @@ function applyConfigUpdate(agent, key, rawValue) {
     throw new Error(`Unknown config key: "${key}". Valid keys: ${Object.keys(CONFIG_KEY_MAP).join(", ")}`);
   }
   const parsed = parseValue(rawValue);
-  if (key === "engineSettings" && !isRecord(parsed)) {
+  if (key === "engineSettings" && !isRecord2(parsed)) {
     throw new Error("engineSettings must be a JSON object");
   }
   let target = updated;
@@ -80672,7 +81313,7 @@ function parseValue(raw) {
   }
   return parsed;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parsePromptTokens(prompt) {
@@ -85486,7 +86127,7 @@ class TextApiResponse2 {
 var package_default3 = {
   name: "@uipath/solution-sdk",
   license: "MIT",
-  version: "1.197.0-preview.65",
+  version: "1.197.0-preview.66",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -86290,7 +86931,7 @@ async function readUipxFile(fs7, solutionDir) {
   return { uipx, uipxFileName };
 }
 function validateUipxFile(parsed, uipxFileName) {
-  if (!isRecord2(parsed)) {
+  if (!isRecord3(parsed)) {
     throw new Error(`Invalid .uipx file: ${uipxFileName} must contain a JSON object.`);
   }
   if (typeof parsed.SolutionId !== "string" || !parsed.SolutionId.trim()) {
@@ -86300,7 +86941,7 @@ function validateUipxFile(parsed, uipxFileName) {
     throw new Error("Invalid .uipx file: missing Projects.");
   }
   for (const [index, project] of parsed.Projects.entries()) {
-    if (!isRecord2(project)) {
+    if (!isRecord3(project)) {
       throw new Error(`Invalid .uipx file: Projects[${index}] must be an object.`);
     }
     if (typeof project.ProjectRelativePath !== "string" || !project.ProjectRelativePath.trim()) {
@@ -86310,7 +86951,7 @@ function validateUipxFile(parsed, uipxFileName) {
   }
   return parsed;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function updateUipxSolutionId(fs7, uipxPath, newSolutionId) {
@@ -86568,11 +87209,11 @@ async function readProjectManifest(fs7, filePath, useProjectJson) {
       null
     ];
   }
-  if (!isRecord2(parsed)) {
+  if (!isRecord3(parsed)) {
     return [new Error(`Invalid project file: ${filePath}`), null];
   }
   const designOptions = parsed.designOptions;
-  const outputType = useProjectJson && isRecord2(designOptions) ? readString(designOptions.outputType) : undefined;
+  const outputType = useProjectJson && isRecord3(designOptions) ? readString(designOptions.outputType) : undefined;
   const projectType = outputType ?? readString(parsed.ProjectType);
   if (!projectType) {
     return [new Error(`ProjectType not found in ${filePath}`), null];
@@ -86599,7 +87240,7 @@ async function readSolutionManifest(fs7, solutionFile) {
       null
     ];
   }
-  if (!isRecord2(parsed)) {
+  if (!isRecord3(parsed)) {
     return [
       new Error(`Invalid solution file: ${solutionFile} must contain a JSON object.`),
       null
@@ -86613,7 +87254,7 @@ async function readSolutionManifest(fs7, solutionFile) {
   }
   const projects = [];
   for (const [index, project] of parsed.Projects.entries()) {
-    if (!isRecord2(project)) {
+    if (!isRecord3(project)) {
       return [
         new Error(`Invalid solution file: Projects[${index}] must be an object.`),
         null
@@ -87949,7 +88590,7 @@ var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}
 function isUUID(value) {
   return UUID_PATTERN2.test(value);
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toForwardSlash2(path3) {
@@ -87998,7 +88639,7 @@ class AgentLocalWorkspaceEvalPreparer {
     }
     const projectFileContent = await this.fs.readFile(projectFilePath, "utf-8");
     const [projectFileError, parsedProjectFile] = catchError(() => JSON.parse(String(projectFileContent)));
-    if (projectFileError || !isRecord3(parsedProjectFile)) {
+    if (projectFileError || !isRecord4(parsedProjectFile)) {
       throw new Error(`Invalid project.uiproj in ${agentDir}: ${projectFileError?.message ?? "expected a JSON object"}`);
     }
     const projectFile = {
@@ -88644,6 +89285,16 @@ var registerDeployCommand = (program2) => {
           },
           Instructions: provisionedFolderId ? `Deployment active and provisioned. Run: agent run list --folder-id ${provisionedFolderId}` : "Deployment active. Use 'agent run list --folder-id <id>' to find releases, then 'agent run start' to run."
         });
+        trackShipSucceeded({
+          ship_kind: "deploy",
+          target: "orchestrator",
+          project_type: "low_code_agent",
+          command_name: "uip.agent.deploy",
+          artifact_correlation_key: deploymentKey,
+          deployment_key: deploymentKey,
+          package_version_key: packageVersionKey,
+          folder_key: activateResult.installedRootFolderKey
+        });
       } else {
         OutputFormatter.success({
           Result: RESULTS.Success,
@@ -88659,6 +89310,16 @@ var registerDeployCommand = (program2) => {
           },
           Instructions: options.skipActivate ? `Installed${provisionedFolderId ? " and provisioned" : ""} but not activated. Activate manually or re-run without --skip-activate.` : `Deployment installed${provisionedFolderId ? " and provisioned" : ""}. Activate when ready.`
         });
+        trackShipSucceeded({
+          ship_kind: "deploy",
+          target: "orchestrator",
+          project_type: "low_code_agent",
+          command_name: "uip.agent.deploy",
+          artifact_correlation_key: deploymentKey,
+          deployment_key: deploymentKey,
+          package_version_key: packageVersionKey,
+          folder_key: installResult.installedRootFolderKey
+        });
       }
     })());
     if (error) {
@@ -89072,7 +89733,7 @@ class VoidApiResponse3 {
 var package_default4 = {
   name: "@uipath/agent-sdk",
   license: "MIT",
-  version: "1.197.0-preview.65",
+  version: "1.197.0-preview.66",
   description: "SDK for the UiPath Agent Runtime API — evaluation execution and debug sessions.",
   repository: {
     type: "git",
@@ -93991,6 +94652,110 @@ async function uploadNupkgsToOrchestrator(solutionZipPath, loginStatus2, folderO
   }
   return { releases };
 }
+async function resolveAgentUisPath(inputPath, packageNameOverride) {
+  const fs7 = getFileSystem();
+  const absPath = fs7.path.resolve(inputPath);
+  const pathExists = await fs7.exists(absPath);
+  if (!pathExists || absPath.endsWith(".uis")) {
+    return { absPath, uisPath: absPath };
+  }
+  const projectService = new AgentProjectService;
+  const validation = await projectService.validateProjectStructure(absPath);
+  if (!validation.valid) {
+    throw new Error(`Invalid agent project:
+${validation.errors.join(`
+`)}`);
+  }
+  const agent = await projectService.readAgentJson(absPath);
+  const packageName = packageNameOverride ?? agent.metadata.name ?? fs7.path.basename(absPath);
+  const tempDir = fs7.path.join(fs7.env.tmpdir(), `agent-publish-${Date.now()}`);
+  await fs7.mkdir(tempDir);
+  const uisPath = fs7.path.join(tempDir, `${packageName}.uis`);
+  await createArchive(absPath, uisPath);
+  OutputFormatter.log({
+    Message: `Packed agent to ${uisPath}`
+  });
+  return { absPath, uisPath };
+}
+async function publishDirectAgentPackage(zipPath, loginStatus2, tenantName, packageName, packageVersion, folderId) {
+  OutputFormatter.log({
+    Message: "Uploading packages directly to Orchestrator..."
+  });
+  const result = await uploadNupkgsToOrchestrator(zipPath, { ...loginStatus2, tenantName }, folderId);
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: "AgentPublish",
+    Data: {
+      Status: "Published to Orchestrator (direct)",
+      Name: packageName,
+      Version: packageVersion,
+      Releases: result.releases.map((r) => ({
+        Name: r.name,
+        Key: r.key,
+        ProcessKey: r.processKey
+      }))
+    }
+  });
+  const firstRelease = result.releases[0];
+  trackShipSucceeded({
+    ship_kind: "publish",
+    target: folderId ? "orchestrator_folder_package_feed" : "orchestrator_tenant_package_feed",
+    project_type: "low_code_agent",
+    command_name: "uip.agent.publish",
+    artifact_correlation_key: firstRelease?.processKey ?? firstRelease?.key ?? `${packageName}:${packageVersion}`,
+    package_name: packageName,
+    package_version: packageVersion,
+    folder_key: folderId
+  });
+}
+async function publishSolutionAgentPackage(zipPath, loginStatus2, tenantName, packageName, packageVersion, locationKey) {
+  const fs7 = getFileSystem();
+  OutputFormatter.log({
+    Message: "Publishing to Orchestrator..."
+  });
+  const fileBuffer = await fs7.readFile(zipPath);
+  if (!fileBuffer) {
+    throw new Error(`Failed to read solution zip: ${zipPath}`);
+  }
+  const basePath = `${loginStatus2.baseUrl}/${loginStatus2.organizationId}/${tenantName}/automationsolutions_`;
+  const configuration = new Configuration3({
+    basePath,
+    accessToken: loginStatus2.accessToken
+  });
+  const api2 = new PackagesApi(configuration);
+  const packageVersionKey = await api2.packagesUpload({
+    locationKey,
+    body: fileBuffer
+  });
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: "AgentPublish",
+    Data: {
+      Status: "Published successfully",
+      Name: packageName,
+      Version: packageVersion,
+      PackageVersionKey: packageVersionKey
+    },
+    Instructions: "Deploy via Orchestrator UI or use --direct flag for direct upload."
+  });
+  trackShipSucceeded({
+    ship_kind: "publish",
+    target: "tenant_solution_feed",
+    project_type: "low_code_agent",
+    command_name: "uip.agent.publish",
+    artifact_correlation_key: packageVersionKey,
+    package_version_key: packageVersionKey,
+    package_name: packageName,
+    package_version: packageVersion
+  });
+}
+async function publishPackedAgentPackage(zipPath, loginStatus2, tenantName, packageName, options) {
+  if (options.direct) {
+    await publishDirectAgentPackage(zipPath, loginStatus2, tenantName, packageName, options.packageVersion, options.folderId);
+    return;
+  }
+  await publishSolutionAgentPackage(zipPath, loginStatus2, tenantName, packageName, options.packageVersion, options.locationKey);
+}
 var registerPublishCommand = (program2) => {
   program2.command("publish").description("Pack and publish an agent to UiPath Orchestrator").argument("[path]", "Path to agent project directory or .uis file", ".").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant>")).option("-l, --location-key <guid>", "Location key (optional GUID)").option("-n, --name <name>", "Package name (default: agent name)").option("--package-version <version>", "Package version (default: 1.0.0)", "1.0.0").option("--folder-id <id>", "Orchestrator folder org unit ID for direct upload").option("--direct", "Upload nupkg directly to Orchestrator (bypasses solution deployment)").option("--login-validity <minutes>", "Minimum minutes before token expiration", (v) => Number.parseInt(v, 10), 10).examples(PUBLISH_EXAMPLES).trackedAction(processContext, async (inputPath, options) => {
     const [error40] = await catchError((async () => {
@@ -94001,35 +94766,13 @@ var registerPublishCommand = (program2) => {
       if (loginStatus2.loginStatus !== "Logged in" || !loginStatus2.accessToken || !loginStatus2.baseUrl || !loginStatus2.organizationId) {
         throw new Error("Not logged in. Run 'uip login' first.");
       }
-      const absPath = fs7.path.resolve(inputPath);
-      let uisPath;
-      const pathExists = await fs7.exists(absPath);
-      if (pathExists && !absPath.endsWith(".uis")) {
-        const projectService = new AgentProjectService;
-        const validation = await projectService.validateProjectStructure(absPath);
-        if (!validation.valid) {
-          throw new Error(`Invalid agent project:
-${validation.errors.join(`
-`)}`);
-        }
-        const agent = await projectService.readAgentJson(absPath);
-        const packageName2 = options.name ?? agent.metadata.name ?? fs7.path.basename(absPath);
-        const tempDir = fs7.path.join(fs7.env.tmpdir(), `agent-publish-${Date.now()}`);
-        await fs7.mkdir(tempDir);
-        uisPath = fs7.path.join(tempDir, `${packageName2}.uis`);
-        await createArchive(absPath, uisPath);
-        OutputFormatter.log({
-          Message: `Packed agent to ${uisPath}`
-        });
-      } else {
-        uisPath = absPath;
-      }
+      const { absPath, uisPath } = await resolveAgentUisPath(inputPath, options.name);
       const { execFile: execFile7 } = await import("node:child_process");
       const { promisify: promisify7 } = await import("node:util");
       const execFileAsync5 = promisify7(execFile7);
       const packOutputDir = fs7.path.join(fs7.env.tmpdir(), `agent-pack-output-${Date.now()}`);
       await fs7.mkdir(packOutputDir);
-      const packageName = options.name ?? fs7.path.basename(fs7.path.resolve(inputPath), ".uis");
+      const packageName = options.name ?? fs7.path.basename(absPath, ".uis");
       const uipPath = process.argv[1];
       if (!uipPath) {
         throw new Error("Could not determine CLI entry point from process.argv.");
@@ -94065,55 +94808,7 @@ ${validation.errors.join(`
       if (!tenantName) {
         throw new Error("Tenant must be selected during login. Run 'uip login' or 'uip login tenant set <tenant>'.");
       }
-      if (options.direct) {
-        OutputFormatter.log({
-          Message: "Uploading packages directly to Orchestrator..."
-        });
-        const result = await uploadNupkgsToOrchestrator(zipPath, { ...loginStatus2, tenantName }, options.folderId);
-        OutputFormatter.success({
-          Result: RESULTS.Success,
-          Code: "AgentPublish",
-          Data: {
-            Status: "Published to Orchestrator (direct)",
-            Name: packageName,
-            Version: options.packageVersion,
-            Releases: result.releases.map((r) => ({
-              Name: r.name,
-              Key: r.key,
-              ProcessKey: r.processKey
-            }))
-          }
-        });
-      } else {
-        OutputFormatter.log({
-          Message: "Publishing to Orchestrator..."
-        });
-        const fileBuffer = await fs7.readFile(zipPath);
-        if (!fileBuffer) {
-          throw new Error(`Failed to read solution zip: ${zipPath}`);
-        }
-        const basePath = `${loginStatus2.baseUrl}/${loginStatus2.organizationId}/${tenantName}/automationsolutions_`;
-        const configuration = new Configuration3({
-          basePath,
-          accessToken: loginStatus2.accessToken
-        });
-        const api2 = new PackagesApi(configuration);
-        const packageVersionKey = await api2.packagesUpload({
-          locationKey: options.locationKey,
-          body: fileBuffer
-        });
-        OutputFormatter.success({
-          Result: RESULTS.Success,
-          Code: "AgentPublish",
-          Data: {
-            Status: "Published successfully",
-            Name: packageName,
-            Version: options.packageVersion,
-            PackageVersionKey: packageVersionKey
-          },
-          Instructions: "Deploy via Orchestrator UI or use --direct flag for direct upload."
-        });
-      }
+      await publishPackedAgentPackage(zipPath, loginStatus2, tenantName, packageName, options);
     })());
     if (error40) {
       OutputFormatter.error({
@@ -94395,7 +95090,7 @@ function extractSolutions(value) {
   if (Array.isArray(value)) {
     return value.filter(isStudioSolutionSummary);
   }
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return [];
   }
   for (const key of ["value", "data", "items", "results"]) {
@@ -94407,9 +95102,9 @@ function extractSolutions(value) {
   return [];
 }
 function isStudioSolutionSummary(value) {
-  return isRecord4(value) && typeof value.name === "string" && (value.id === undefined || typeof value.id === "string") && (value.solutionId === undefined || typeof value.solutionId === "string");
+  return isRecord5(value) && typeof value.name === "string" && (value.id === undefined || typeof value.id === "string") && (value.solutionId === undefined || typeof value.solutionId === "string");
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -99212,17 +99907,17 @@ async function loadGuardrailPolicies(value) {
   return normalizeGuardrailPolicies(fileParsed);
 }
 function normalizeGuardrailPolicies(value) {
-  const policies = Array.isArray(value) ? value : isRecord5(value) && Array.isArray(value.policies) ? value.policies : isRecord5(value) ? [value] : undefined;
+  const policies = Array.isArray(value) ? value : isRecord6(value) && Array.isArray(value.policies) ? value.policies : isRecord6(value) ? [value] : undefined;
   if (!policies) {
     throw new Error("Guardrails must be a JSON policy object, an array of policies, or an object with a policies array.");
   }
   return policies.map(normalizeGuardrailPolicy);
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeGuardrailPolicy(value) {
-  if (!isRecord5(value) || !instanceOfAgentGuardrailPolicy(value) || !isRecord5(value.action)) {
+  if (!isRecord6(value) || !instanceOfAgentGuardrailPolicy(value) || !isRecord6(value.action)) {
     throw new Error("Each guardrail policy must be a JSON object with an action object.");
   }
   return value;
@@ -99279,4 +99974,4 @@ export {
   metadata
 };
 
-//# debugId=D20CAD332169916D64756E2164756E21
+//# debugId=C57508477C5C9A0C64756E2164756E21

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/agent-tool",
   "license": "MIT",
-  "version": "1.197.0-preview.65",
+  "version": "1.197.0-preview.66",
   "description": "cli plugin for creating and managing UiPath low-code agents",
   "private": false,
   "repository": {
@@ -26,5 +26,5 @@
   "files": [
     "dist"
   ],
-  "gitHead": "9388ccbe5e739c9578bfd9b5395980fb63e11d9c"
+  "gitHead": "386b0837882b19062bf744c74949cdf9c5e48dea"
 }