@uipath/common 1.197.0-preview.65 → 1.197.0-preview.67

package/dist/formatter.d.ts

@@ -1,3 +1,4 @@
+import { type CommandErrorClass, type TerminalOutcome } from "./telemetry/command-terminal.js";
 export type OutputFormat = "table" | "json" | "yaml" | "plain";
 export type ResultType = "Success" | "Failure" | "ConfigError" | "AuthenticationError" | "ValidationError" | "TimeoutError";
 export type FailureResultType = Exclude<ResultType, "Success">;
@@ -100,6 +101,12 @@ export declare class FailureOutput {
      * stuck auth-refresh loop). Stripped before the envelope is rendered.
      */
     SuppressTelemetry?: boolean;
+    /** Internal-only override for command-level telemetry. Stripped before rendering. */
+    TelemetryErrorClass?: CommandErrorClass;
+    /** Internal-only override for command-level telemetry. Stripped before rendering. */
+    TelemetryTerminalOutcome?: TerminalOutcome;
+    /** Internal-only override for command-level telemetry. Stripped before rendering. */
+    TelemetryTerminalSignal?: string;
     constructor(result: FailureResultType, message: string, instructions: string, context?: ErrorContext, errorCode?: CliErrorCode, retry?: RetryHint);
 }
 export type StructuredOutput = SuccessOutput | FailureOutput;

package/dist/index.browser.d.ts

@@ -22,8 +22,11 @@ export * from "./screen-logger";
 export * from "./sdk-user-agent";
 export * from "./singleton";
 export { BrowserContextStorage } from "./telemetry/browser-context-storage.js";
+export * from "./telemetry/command-attribution.js";
+export * from "./telemetry/command-terminal.js";
 export { ConsoleTelemetryProvider } from "./telemetry/console-telemetry-provider.js";
 export type { IContextStorage } from "./telemetry/context-storage.js";
+export { getConfiguredTelemetrySessionId, getTelemetrySessionId, resolveTelemetrySessionId, TELEMETRY_SESSION_ID_ENV, TELEMETRY_SESSION_ID_PROPERTY, } from "./telemetry/session-id.js";
 export * from "./telemetry/telemetry-events.js";
 export type { ITelemetryProvider } from "./telemetry/telemetry-provider.js";
 export type { ITelemetryService, TelemetryContext, TelemetryProperties, } from "./telemetry/telemetry-service.js";

package/dist/index.browser.js

@@ -22360,6 +22360,392 @@ class BrowserContextStorage {
     return this.contextStack.length > 0 ? this.contextStack[this.contextStack.length - 1] : undefined;
   }
 }
+// src/telemetry/command-attribution.ts
+var LEGACY_SKILL_NAMESPACE = "uipath:";
+var MAX_SKILL_NAME_LENGTH = 80;
+var SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+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;
+}
+var 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"]]
+]);
+var KNOWN_SKILL_NAMES = new Set(Object.keys(SKILL_ATTRIBUTION));
+var 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);
+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 normalizeLegacySkillName(value) {
+  return normalizeSkillNameWithOptions(value, {
+    allowLegacyNamespace: true
+  });
+}
+function buildCommandTelemetryAttribution(commandPath, skillSource) {
+  const skillName = normalizeSkillName(skillSource);
+  return {
+    ...skillName ? { skill_name: skillName } : {},
+    ...getCommandProductModeAttribution(commandPath)
+  };
+}
+function buildSkillEventTelemetryAttribution(skillSource, uipSubcommand) {
+  const skillName = normalizeLegacySkillName(skillSource);
+  const skillAttribution = skillName ? SKILL_ATTRIBUTION[skillName] : {};
+  const commandAttribution2 = getCommandProductModeAttribution(uipSubcommand);
+  return {
+    ...skillAttribution,
+    ...commandAttribution2,
+    ...skillName ? { skill_name: skillName } : {}
+  };
+}
+// src/telemetry/command-terminal.ts
+var recordedFailureSlot = singleton("CommandTelemetryFailure");
+var AUTH_ERROR_CODES = new Set([
+  "authentication_required",
+  "permission_denied"
+]);
+var VALIDATION_ERROR_CODES = new Set(["invalid_argument"]);
+var NETWORK_HTTP_ERROR_CODES = new Set([
+  "network_error",
+  "rate_limited",
+  "server_error",
+  "not_found",
+  "method_not_allowed"
+]);
+var TIMEOUT_ERROR_CODES = new Set(["timeout"]);
+var NETWORK_OS_ERROR_CODES = new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EPIPE",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "EAI_FAIL"
+]);
+var TIMEOUT_OS_ERROR_CODES = new Set(["ETIMEDOUT", "ESOCKETTIMEDOUT"]);
+var 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"
+]);
+var MISSING_DEPENDENCY_CODES = new Set([
+  "MODULE_NOT_FOUND",
+  "ERR_MODULE_NOT_FOUND"
+]);
+var INTERNAL_ERROR_NAMES = new Set([
+  "TypeError",
+  "ReferenceError",
+  "SyntaxError",
+  "RangeError"
+]);
+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 code2 = findCodeInCauseChain(error);
+  if (code2 !== "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 code2 = findCodeInCauseChain(error);
+  if (code2) {
+    if (code2.startsWith("commander.")) {
+      return "validation";
+    }
+    if (NETWORK_OS_ERROR_CODES.has(code2) || TLS_ERROR_CODES2.has(code2)) {
+      return "network_http";
+    }
+    if (TIMEOUT_OS_ERROR_CODES.has(code2)) {
+      return "timeout";
+    }
+    if (MISSING_DEPENDENCY_CODES.has(code2) || 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 classifyError2(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 getRecordedCommandFailureTelemetry() {
+  return recordedFailureSlot.get();
+}
+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" : classifyError2(input);
+  const terminalSignal = terminalSignalFor(input, outcome);
+  return {
+    exit_code: input.exitCode,
+    terminal_outcome: outcome,
+    ...errorClass ? { error_class: errorClass } : {},
+    ...terminalSignal ? { terminal_signal: terminalSignal } : {}
+  };
+}
 // src/telemetry/console-telemetry-provider.ts
 class ConsoleTelemetryProvider {
   async trackEvent(eventName, _properties) {
@@ -22375,10 +22761,174 @@ class ConsoleTelemetryProvider {
     console.debug(`[Telemetry] Dependency: ${name} [${type}] (${duration}ms, ${success ? "ok" : "fail"})`);
   }
 }
+// src/telemetry/session-id.ts
+var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID";
+var TELEMETRY_SESSION_ID_PROPERTY = "session_id";
+var telemetrySessionIdSlot = singleton("TelemetrySessionId");
+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 getTelemetrySessionId() {
+  const envSessionId = getConfiguredTelemetrySessionId();
+  if (envSessionId) {
+    return envSessionId;
+  }
+  const existing = telemetrySessionIdSlot.get();
+  if (existing) {
+    return existing;
+  }
+  const generated = crypto.randomUUID();
+  telemetrySessionIdSlot.set(generated);
+  return generated;
+}
+function resolveTelemetrySessionId(existingSessionId) {
+  return getConfiguredTelemetrySessionId() ?? normalizeSessionId(existingSessionId);
+}
 // src/telemetry/telemetry-events.ts
 var CommonTelemetryEvents = {
-  Error: "uip.error"
+  Error: "uip.error",
+  ShipSucceeded: "ship_succeeded"
 };
+// src/telemetry/detect-agent.ts
+var 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" }
+];
+function detectAgentFromEnv(env2) {
+  for (const agent of KNOWN_AGENTS) {
+    const envValue = env2[agent.envVar];
+    if (agent.value !== undefined) {
+      if (envValue === agent.value)
+        return agent.id;
+    } else {
+      if (envValue)
+        return agent.id;
+    }
+  }
+  const agentEnv = env2.AGENT;
+  if (agentEnv) {
+    if (agentEnv === "1" || agentEnv === "true")
+      return "unknown";
+    if (agentEnv.length <= 32)
+      return agentEnv.toLowerCase();
+  }
+  return;
+}
+
+// src/telemetry/execution-context.ts
+var authSignalSlot = singleton("TelemetryExecutionContextAuthSignal");
+var isTruthy = (value) => value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
+var isEqual = (value, expected) => value?.toLowerCase() === expected;
+var CI_SIGNATURES = [
+  {
+    provider: "github_actions",
+    matches: (env2) => isTruthy(env2.GITHUB_ACTIONS),
+    isScheduler: (env2) => env2.GITHUB_EVENT_NAME === "schedule"
+  },
+  {
+    provider: "azure_devops",
+    matches: (env2) => isTruthy(env2.TF_BUILD),
+    isScheduler: (env2) => isEqual(env2.BUILD_REASON, "schedule")
+  },
+  {
+    provider: "gitlab",
+    matches: (env2) => isTruthy(env2.GITLAB_CI),
+    isScheduler: (env2) => env2.CI_PIPELINE_SOURCE === "schedule"
+  },
+  {
+    provider: "circleci",
+    matches: (env2) => isTruthy(env2.CIRCLECI),
+    isScheduler: (env2) => env2.CIRCLE_PIPELINE_TRIGGER_SOURCE === "scheduled_pipeline"
+  },
+  {
+    provider: "jenkins",
+    matches: (env2) => isTruthy(env2.JENKINS_URL) || isTruthy(env2.JENKINS_HOME)
+  },
+  {
+    provider: "teamcity",
+    matches: (env2) => isTruthy(env2.TEAMCITY_VERSION)
+  },
+  {
+    provider: "buildkite",
+    matches: (env2) => isTruthy(env2.BUILDKITE),
+    isScheduler: (env2) => env2.BUILDKITE_SOURCE === "schedule"
+  },
+  {
+    provider: "bitbucket",
+    matches: (env2) => isTruthy(env2.BITBUCKET_BUILD_NUMBER)
+  },
+  {
+    provider: "travis",
+    matches: (env2) => isTruthy(env2.TRAVIS)
+  },
+  {
+    provider: "appveyor",
+    matches: (env2) => isTruthy(env2.APPVEYOR)
+  },
+  {
+    provider: "generic",
+    matches: (env2) => isTruthy(env2.CI)
+  }
+];
+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(env2) {
+  const signature = CI_SIGNATURES.find((candidate) => candidate.matches(env2));
+  if (!signature)
+    return;
+  return {
+    executionContext: signature.isScheduler?.(env2) ? "scheduler" : "ci",
+    ciProvider: signature.provider
+  };
+}
+function detectExecutionContext(options = {}) {
+  const env2 = options.env ?? currentEnv();
+  const ci = detectCi(env2);
+  if (ci)
+    return ci;
+  const agent = options.agent ?? detectAgentFromEnv(env2);
+  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 } : {}
+  };
+}
+
 // src/telemetry/telemetry-service.ts
 class TelemetryService {
   telemetryProvider;
@@ -22457,12 +23007,22 @@ 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("-", "");
@@ -22482,6 +23042,7 @@ async function ensurePackagerFactory(verb) {
 }
 export {
   withCompleter,
+  takeRecordedCommandFailureTelemetry,
   singleton,
   setSdkUserAgentHostToken,
   setPackagerFactoryProvider,
@@ -22492,15 +23053,18 @@ export {
   setGlobalLogFilePath,
   runWithSink,
   restoreConsole,
+  resolveTelemetrySessionId,
   resolveEnvReference,
   resetLoggerInstance,
   registerPackageMetadataOptions,
+  recordCommandFailureTelemetry,
   pollUntil,
   parsePositiveInteger,
   parseOffset,
   parseNonNegativeInteger,
   parseLimit,
   parseBoundedInt,
+  normalizeSkillName,
   msToDuration,
   mapPollFailure,
   mapPackageMetadataOptions,
@@ -22515,13 +23079,16 @@ export {
   installSdkCodingAgentHeader,
   installConsoleGuard,
   hashContent,
+  getTelemetrySessionId,
   getSdkUserAgentToken,
+  getRecordedCommandFailureTelemetry,
   getOutputSink,
   getOutputFormatExplicit,
   getOutputFormat,
   getOutputFilter,
   getLogFilePath,
   getGlobalLogFilePath,
+  getConfiguredTelemetrySessionId,
   getCompleter,
   getCommandExamples,
   extractFormatFromArgs,
@@ -22534,14 +23101,20 @@ export {
   createPollAbortController,
   configureLogger,
   collectCommands,
+  clearRecordedCommandFailureTelemetry,
   catchError,
+  buildSkillEventTelemetryAttribution,
   buildOrchestratorUrl,
+  buildCommandTerminalTelemetryProperties,
+  buildCommandTelemetryAttribution,
   buildActionCenterTaskUrl,
   buildActionCenterInboxUrl,
   addSdkUserAgentHeader,
   addSdkCodingAgentHeader,
   UIPATH_HOME_DIR,
   TelemetryService,
+  TELEMETRY_SESSION_ID_PROPERTY,
+  TELEMETRY_SESSION_ID_ENV,
   ScreenLogger,
   PollOutcome,
   POLL_DEFAULTS,
@@ -22562,4 +23135,4 @@ export {
   AUTH_FILENAME
 };
 
-//# debugId=D3F1D2DAD96E966264756E2164756E21
+//# debugId=ACC353BBF445886C64756E2164756E21