@uipath/common 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/telemetry/index.js

@@ -18164,12 +18164,177 @@ class BrowserContextStorage {
     return this.contextStack.length > 0 ? this.contextStack[this.contextStack.length - 1] : undefined;
   }
 }
+// src/telemetry/telemetry-dimensions.ts
+var CLI_APPLICATION_NAME = "UiPath.Cli";
+var BaseDimensions = {
+  ApplicationName: "ApplicationName",
+  ProductVersion: "ProductVersion",
+  InstallationId: "InstallationId",
+  CloudUserId: "CloudUserId",
+  CloudTenantId: "CloudTenantId",
+  CloudOrganizationId: "CloudOrganizationId",
+  IsInternalUser: "IsInternalUser",
+  Environment: "Environment",
+  BaseUrl: "BaseUrl",
+  Region: "Region",
+  Agent: "Agent",
+  AgentVersion: "AgentVersion",
+  AgentModel: "AgentModel",
+  ToolName: "ToolName",
+  ToolVersion: "ToolVersion",
+  ExecutionContext: "ExecutionContext",
+  CiProvider: "CiProvider",
+  SessionIdSource: "SessionIdSource",
+  SessionId: "SessionId"
+};
+var CommandDimensions = {
+  IsCommand: "IsCommand",
+  IsReexec: "IsReexec",
+  CommandName: "CommandName",
+  ExitCode: "ExitCode",
+  TerminalOutcome: "TerminalOutcome",
+  ErrorClass: "ErrorClass",
+  TerminalSignal: "TerminalSignal",
+  ErrorMessage: "ErrorMessage",
+  SkillName: "SkillName",
+  ProductArea: "ProductArea",
+  Mode: "Mode"
+};
+var ShipDimensions = {
+  ShipKind: "ShipKind",
+  Target: "Target",
+  ProjectType: "ProjectType",
+  ProjectTypes: "ProjectTypes",
+  ArtifactCorrelationKey: "ArtifactCorrelationKey",
+  PackageName: "PackageName",
+  PackageVersion: "PackageVersion",
+  PackageVersionKey: "PackageVersionKey",
+  DeploymentKey: "DeploymentKey",
+  SolutionId: "SolutionId",
+  FolderKey: "FolderKey",
+  FeedId: "FeedId"
+};
+var ErrorDimensions = {
+  Result: "Result",
+  ErrorCode: "ErrorCode",
+  Retry: "Retry",
+  ErrorMessage: "ErrorMessage"
+};
+var AuthDimensions = {
+  AuthenticationMethod: "AuthenticationMethod",
+  Success: "Success",
+  Reason: "Reason"
+};
+var SkillsDimensions = {
+  SchemaVersion: "SchemaVersion",
+  AgentType: "AgentType",
+  SkillsVersion: "SkillsVersion",
+  UipSubcommand: "UipSubcommand",
+  FileExtension: "FileExtension",
+  SubagentModel: "SubagentModel",
+  SubagentType: "SubagentType",
+  PermissionMode: "PermissionMode",
+  EffortLevel: "EffortLevel",
+  SessionSource: "SessionSource",
+  Outcome: "Outcome",
+  DurationMs: "DurationMs",
+  Source: "Source"
+};
+var PackagerDimensions = {
+  ProjectId: "ProjectId",
+  ProjectType: "ProjectType",
+  SolutionId: "SolutionId"
+};
+var ScopeDimensions = {
+  FolderId: "FolderId"
+};
+var ID_DIMENSIONS = new Set([
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.InstallationId,
+  ShipDimensions.ArtifactCorrelationKey,
+  ShipDimensions.PackageVersionKey,
+  ShipDimensions.DeploymentKey,
+  ShipDimensions.SolutionId,
+  ShipDimensions.FolderKey,
+  ShipDimensions.FeedId,
+  PackagerDimensions.ProjectId
+]);
+var NON_IDENTIFIER_PLACEHOLDER_PATTERN = /^(?:\[[A-Z_]+\]|<[^>]+>)$/;
+var DIMENSION_NAME_EXEMPT_PREFIXES = [
+  "uip.cmd.arg.",
+  "server.",
+  "http."
+];
+function isExemptDimensionName(name) {
+  return DIMENSION_NAME_EXEMPT_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+var DIMENSION_NAME_PATTERN = /^[A-Z][A-Za-z0-9]*$/;
+var EVENT_NAME_PATTERN = /^[A-Z][A-Za-z0-9]*\.[A-Z][A-Za-z0-9]*$/;
+var RESERVED_DIMENSION_NAMES = new Set([
+  ...Object.values(BaseDimensions),
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions),
+  ...Object.values(ErrorDimensions),
+  ...Object.values(AuthDimensions),
+  ...Object.values(SkillsDimensions),
+  ...Object.values(PackagerDimensions),
+  ...Object.values(ScopeDimensions)
+]);
+var CURATED_DIMENSIONS = new Set([
+  BaseDimensions.ApplicationName,
+  BaseDimensions.ProductVersion,
+  BaseDimensions.InstallationId,
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.IsInternalUser,
+  BaseDimensions.Environment,
+  BaseDimensions.BaseUrl,
+  BaseDimensions.Region,
+  BaseDimensions.Agent,
+  BaseDimensions.AgentVersion,
+  BaseDimensions.ToolVersion,
+  BaseDimensions.ExecutionContext,
+  BaseDimensions.CiProvider,
+  BaseDimensions.SessionIdSource,
+  BaseDimensions.SessionId,
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions)
+]);
+function assertNoCuratedDimensionTargets(map, mapName) {
+  for (const [inputKey, dimension] of Object.entries(map)) {
+    if (CURATED_DIMENSIONS.has(dimension)) {
+      throw new Error(`${mapName}: input field "${inputKey}" maps to curated dimension "${dimension}"`);
+    }
+  }
+}
+function lowercaseIdDimensionValues(properties) {
+  let changed = false;
+  const result = {
+    ...properties
+  };
+  for (const key of Object.keys(result)) {
+    const value = result[key];
+    if (!ID_DIMENSIONS.has(key) || typeof value !== "string" || NON_IDENTIFIER_PLACEHOLDER_PATTERN.test(value)) {
+      continue;
+    }
+    const lowered = value.toLowerCase();
+    if (lowered !== value) {
+      result[key] = lowered;
+      changed = true;
+    }
+  }
+  return changed ? result : properties;
+}
+
 // 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 };
+  return { ProductArea: productArea, Mode: mode };
 }
 function attributionRecord(groups) {
   const record = {};
@@ -18227,6 +18392,7 @@ var COMMAND_ATTRIBUTION = commandAttribution([
   ["rpa", "build", ["uip.rpa-legacy"]],
   ["conversational", "operate", ["uip.conversational"]],
   ["agents", "build", ["uip.codedagent", "uip.agent"]],
+  ["coding-agents", "build", ["uip.coder"]],
   ["agenthub", "build", ["uip.agenthub"]],
   ["coded-apps", "build", ["uip.codedapp"]],
   ["functions", "build", ["uip.function", "uip.functions"]],
@@ -18317,7 +18483,7 @@ function normalizeLegacySkillName(value) {
 function buildCommandTelemetryAttribution(commandPath, skillSource) {
   const skillName = normalizeSkillName(skillSource);
   return {
-    ...skillName ? { skill_name: skillName } : {},
+    ...skillName ? { SkillName: skillName } : {},
     ...getCommandProductModeAttribution(commandPath)
   };
 }
@@ -18328,9 +18494,29 @@ function buildSkillEventTelemetryAttribution(skillSource, uipSubcommand) {
   return {
     ...skillAttribution,
     ...commandAttribution2,
-    ...skillName ? { skill_name: skillName } : {}
+    ...skillName ? { SkillName: skillName } : {}
   };
 }
+var AGENT_SESSION_ENV = {
+  [BaseDimensions.AgentModel]: "UIPATH_AGENT_MODEL",
+  [SkillsDimensions.PermissionMode]: "UIPATH_PERMISSION_MODE",
+  [SkillsDimensions.EffortLevel]: "UIPATH_EFFORT_LEVEL",
+  [SkillsDimensions.SkillsVersion]: "UIPATH_SKILLS_VERSION"
+};
+var MAX_TELEMETRY_TOKEN_LENGTH = 120;
+function sanitizeTelemetryToken(value) {
+  return value.replace(/[^A-Za-z0-9:._/ -]/g, "_").slice(0, MAX_TELEMETRY_TOKEN_LENGTH);
+}
+function buildAgentSessionTelemetry(env) {
+  const dimensions = {};
+  for (const [key, variable] of Object.entries(AGENT_SESSION_ENV)) {
+    const value = env[variable]?.trim();
+    if (value) {
+      dimensions[key] = sanitizeTelemetryToken(value);
+    }
+  }
+  return dimensions;
+}
 // src/telemetry/console-telemetry-provider.ts
 class ConsoleTelemetryProvider {
   async trackEvent({ name }) {
@@ -18398,14 +18584,14 @@ function deriveRegion(baseUrl) {
 }
 function buildEnvironmentProperties(baseUrl) {
   const props = {
-    environment: normalizeEnvironment(baseUrl)
+    [BaseDimensions.Environment]: normalizeEnvironment(baseUrl)
   };
   const normalized = normalizeBaseUrl(baseUrl);
   if (normalized)
-    props.base_url = normalized;
+    props[BaseDimensions.BaseUrl] = normalized;
   const region = deriveRegion(baseUrl);
   if (region)
-    props.region = region;
+    props[BaseDimensions.Region] = region;
   return props;
 }
 // src/singleton.ts
@@ -18578,8 +18764,8 @@ function detectExecutionContext(options = {}) {
 function getExecutionContextTelemetryProperties() {
   const detected = detectExecutionContext();
   return {
-    execution_context: detected.executionContext,
-    ...detected.ciProvider ? { ci_provider: detected.ciProvider } : {}
+    [BaseDimensions.ExecutionContext]: detected.executionContext,
+    ...detected.ciProvider ? { [BaseDimensions.CiProvider]: detected.ciProvider } : {}
   };
 }
 // src/telemetry/pseudonymize.ts
@@ -19039,7 +19225,7 @@ function getInboundTraceContext() {
 var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID";
 var SESSION_ID_MAX_LENGTH = 64;
 var RANDOM_SESSION_ID_LENGTH = 32;
-var TELEMETRY_SESSION_SOURCE_PROPERTY = "session_id_source";
+var TELEMETRY_SESSION_SOURCE_PROPERTY = "SessionIdSource";
 var CONTROL_CHARACTERS = /\p{Cc}/gu;
 var INHERITED_SESSION_SOURCES = [
   { envVar: "CLAUDE_CODE_SESSION_ID", source: "claude-code" },
@@ -19174,7 +19360,10 @@ class TelemetryService {
     } catch (error) {
       const durationMs = clock.elapsedMs();
       const err = error instanceof Error ? error : new Error(String(error));
-      await this.telemetryProvider.trackRequest(this.spanFor(name, durationMs, false, { ...properties, errorMessage: err.message }, context));
+      await this.telemetryProvider.trackRequest(this.spanFor(name, durationMs, false, {
+        ...properties,
+        [CommandDimensions.ErrorMessage]: err.message
+      }, context));
       throw error;
     }
   }
@@ -19245,7 +19434,10 @@ class TelemetryService {
       const durationMs = clock.elapsedMs();
       const err = error instanceof Error ? error : new Error(String(error));
       await this.telemetryProvider.trackDependency({
-        ...this.spanFor(name, durationMs, false, { ...properties, errorMessage: err.message }, childContext),
+        ...this.spanFor(name, durationMs, false, {
+          ...properties,
+          [CommandDimensions.ErrorMessage]: err.message
+        }, childContext),
         type
       });
       throw error;
@@ -19280,9 +19472,10 @@ class TelemetryService {
       ...globalProperties,
       ...this.defaultProperties,
       ...redactProperties(properties ?? {}),
-      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource()
+      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource(),
+      [BaseDimensions.SessionId]: this.telemetryProvider.getSessionId?.() ?? getTelemetrySessionId()
     };
-    return enriched;
+    return lowercaseIdDimensionValues(enriched);
   }
   generateId() {
     const bytes = new Uint8Array(8);
@@ -19298,12 +19491,29 @@ class TelemetryService {
   }
 }
 export {
+  AuthDimensions,
+  BaseDimensions,
   BrowserContextStorage,
+  CLI_APPLICATION_NAME,
+  CURATED_DIMENSIONS,
+  CommandDimensions,
   ConsoleTelemetryProvider,
+  DIMENSION_NAME_EXEMPT_PREFIXES,
+  DIMENSION_NAME_PATTERN,
+  EVENT_NAME_PATTERN,
   EXECUTION_CONTEXT_VALUES,
+  ErrorDimensions,
+  ID_DIMENSIONS,
+  PackagerDimensions,
+  RESERVED_DIMENSION_NAMES,
+  ScopeDimensions,
+  ShipDimensions,
+  SkillsDimensions,
   TELEMETRY_SESSION_ID_ENV,
   TELEMETRY_SESSION_SOURCE_PROPERTY,
   TelemetryService,
+  assertNoCuratedDimensionTargets,
+  buildAgentSessionTelemetry,
   buildCommandTelemetryAttribution,
   buildEnvironmentProperties,
   buildSkillEventTelemetryAttribution,
@@ -19312,13 +19522,16 @@ export {
   getExecutionContextTelemetryProperties,
   getTelemetrySessionId,
   getTelemetrySessionSource,
+  isExemptDimensionName,
+  lowercaseIdDimensionValues,
   normalizeBaseUrl,
   normalizeEnvironment,
   normalizeSkillName,
   redactError,
   redactProperties,
   redactProperty,
+  sanitizeTelemetryToken,
   setExecutionContextAuthSignal
 };
 
-//# debugId=92AE46794174C94B64756E2164756E21
+//# debugId=185B0F4985CF941364756E2164756E21

package/dist/telemetry/session-id.d.ts

@@ -20,7 +20,7 @@ export declare const RANDOM_SESSION_ID_LENGTH = 32;
  * handles pass through as the host exported them, with no source marker. Low
  * cardinality by construction: one of {@link TelemetrySessionSource}.
  */
-export declare const TELEMETRY_SESSION_SOURCE_PROPERTY = "session_id_source";
+export declare const TELEMETRY_SESSION_SOURCE_PROPERTY = "SessionIdSource";
 /**
  * Where a session id came from — the value of the
  * {@link TELEMETRY_SESSION_SOURCE_PROPERTY} dimension.

package/dist/telemetry/ship-succeeded.d.ts

@@ -1,16 +1,16 @@
 export interface ShipSucceededTelemetryPayload {
-    ship_kind: string;
-    target: string;
-    project_type: string;
-    command_name: string;
-    artifact_correlation_key?: string;
-    package_version_key?: string;
-    package_name?: string;
-    package_version?: string;
-    deployment_key?: string;
-    solution_id?: string;
-    folder_key?: string;
-    feed_id?: string;
-    project_types?: string;
+    ShipKind: string;
+    Target: string;
+    ProjectType: string;
+    CommandName: string;
+    ArtifactCorrelationKey?: string;
+    PackageVersionKey?: string;
+    PackageName?: string;
+    PackageVersion?: string;
+    DeploymentKey?: string;
+    SolutionId?: string;
+    FolderKey?: string;
+    FeedId?: string;
+    ProjectTypes?: string;
 }
 export declare function trackShipSucceeded(payload: ShipSucceededTelemetryPayload): boolean;

package/dist/telemetry/telemetry-dimensions.d.ts

@@ -0,0 +1,237 @@
+/**
+ * The canonical names of every custom dimension the CLI emits.
+ *
+ * UiPath's business-telemetry convention (PRENG-7421) asks for PascalCase
+ * "without word separation of any kind", first-level under `customDimensions`.
+ * Before this existed the repo carried four casings at once — snake_case
+ * (`skill_name`), camelCase (`toolName`), PascalCase (`CloudUserId`) and dotted
+ * namespaces — because nothing named the dimensions in one place and no test
+ * could see the set.
+ *
+ * Producers import a constant from here rather than writing a string literal.
+ * That is deliberate and it is the whole point: a rename map applied at the
+ * emit choke point would have left both spellings alive in the source forever,
+ * and the next person would not know which one was real.
+ *
+ * `telemetry-dimensions.spec.ts` asserts the shape of every value below, and
+ * `telemetry-service.spec.ts` asserts that nothing outside this registry (bar
+ * the exempt prefixes) reaches a provider.
+ */
+/**
+ * The value of {@link BaseDimensions.ApplicationName} for this product.
+ *
+ * `UiPath.[ProductName]` is the convention's shape, and this string is the
+ * join key the analytics estate identifies the CLI by — it is not a label to
+ * reword. Lowercasing it would break that join, which is why
+ * {@link ID_DIMENSIONS} deliberately does not list `ApplicationName`.
+ */
+export declare const CLI_APPLICATION_NAME = "UiPath.Cli";
+/**
+ * Stamped on every item, from the CLI host's startup and auth context.
+ *
+ * `ApplicationName` and `SessionId` are the two the convention requires that
+ * the CLI did not have: the first identifies the product across the shared
+ * analytics estate (and replaces the old `name startswith "uip."` filter), the
+ * second mirrors the native `ai.session.id` tag into a queryable dimension.
+ */
+export declare const BaseDimensions: {
+    /** `UiPath.[ProductName]` — the convention's product identifier. */
+    readonly ApplicationName: "ApplicationName";
+    /** The CLI's own version. Also on the native `ai.application.ver` tag. */
+    readonly ProductVersion: "ProductVersion";
+    /** Random UUID from `~/.uipath/cli-device-id`. Never a machine identifier. */
+    readonly InstallationId: "InstallationId";
+    readonly CloudUserId: "CloudUserId";
+    readonly CloudTenantId: "CloudTenantId";
+    readonly CloudOrganizationId: "CloudOrganizationId";
+    /** Derived from the auth email domain. Only the boolean is emitted. */
+    readonly IsInternalUser: "IsInternalUser";
+    /** `prod` | `staging` | `alpha` | `local` | `unknown`. */
+    readonly Environment: "Environment";
+    /** The auth base URL reduced to its origin. */
+    readonly BaseUrl: "BaseUrl";
+    /** The cloud deployment ring where the host reveals one, e.g. `gov`. */
+    readonly Region: "Region";
+    /** The invoking coding agent, when one was detected. */
+    readonly Agent: "Agent";
+    readonly AgentVersion: "AgentVersion";
+    /** The agent session's main model, as a sanitized slug. */
+    readonly AgentModel: "AgentModel";
+    /** The tool bundle that owns the running command, e.g. `or`. */
+    readonly ToolName: "ToolName";
+    readonly ToolVersion: "ToolVersion";
+    /** `manual` | `agent` | `ci` | `scheduler` | `service_account` | `unknown`. */
+    readonly ExecutionContext: "ExecutionContext";
+    readonly CiProvider: "CiProvider";
+    /** Which host handle produced the session id. CLI-owned, unshadowable. */
+    readonly SessionIdSource: "SessionIdSource";
+    /** The session handle itself, mirroring the native `ai.session.id` tag. */
+    readonly SessionId: "SessionId";
+};
+/** Dimensions a command invocation's request row carries. */
+export declare const CommandDimensions: {
+    /** Marks the row as a command invocation. Unoverridable by a caller. */
+    readonly IsCommand: "IsCommand";
+    /** Marks the delegated half of the version-sync re-exec. */
+    readonly IsReexec: "IsReexec";
+    /** The command path, space-separated — the breakdown the flat name drops. */
+    readonly CommandName: "CommandName";
+    readonly ExitCode: "ExitCode";
+    /** `success` | `no_op` | `failure` | `cancelled`. */
+    readonly TerminalOutcome: "TerminalOutcome";
+    readonly ErrorClass: "ErrorClass";
+    readonly TerminalSignal: "TerminalSignal";
+    readonly ErrorMessage: "ErrorMessage";
+    /** Canonical skill name from `UIPATH_SKILL`. */
+    readonly SkillName: "SkillName";
+    readonly ProductArea: "ProductArea";
+    /** `build` | `operate` | `troubleshoot`. */
+    readonly Mode: "Mode";
+};
+/** Dimensions on `Cli.ShipSucceeded`. */
+export declare const ShipDimensions: {
+    readonly ShipKind: "ShipKind";
+    readonly Target: "Target";
+    readonly ProjectType: "ProjectType";
+    readonly ProjectTypes: "ProjectTypes";
+    readonly ArtifactCorrelationKey: "ArtifactCorrelationKey";
+    readonly PackageName: "PackageName";
+    readonly PackageVersion: "PackageVersion";
+    readonly PackageVersionKey: "PackageVersionKey";
+    readonly DeploymentKey: "DeploymentKey";
+    readonly SolutionId: "SolutionId";
+    readonly FolderKey: "FolderKey";
+    readonly FeedId: "FeedId";
+};
+/** Dimensions on `Application.Error`, from the failure envelope. */
+export declare const ErrorDimensions: {
+    readonly Result: "Result";
+    readonly ErrorCode: "ErrorCode";
+    readonly Retry: "Retry";
+    /** The envelope's `Message`, under the name the convention prescribes. */
+    readonly ErrorMessage: "ErrorMessage";
+};
+/** Dimensions on the `Authenticate.*` events. */
+export declare const AuthDimensions: {
+    /** The login flow. The convention's well-known name for exactly this. */
+    readonly AuthenticationMethod: "AuthenticationMethod";
+    readonly Success: "Success";
+    readonly Reason: "Reason";
+};
+/** Dimensions on the `Cli.Skills*` events, forwarded from the hook payload. */
+export declare const SkillsDimensions: {
+    readonly SchemaVersion: "SchemaVersion";
+    readonly AgentType: "AgentType";
+    readonly SkillsVersion: "SkillsVersion";
+    readonly UipSubcommand: "UipSubcommand";
+    readonly FileExtension: "FileExtension";
+    readonly SubagentModel: "SubagentModel";
+    readonly SubagentType: "SubagentType";
+    readonly PermissionMode: "PermissionMode";
+    readonly EffortLevel: "EffortLevel";
+    /** `startup` | `resume` | `clear` | `compact`. */
+    readonly SessionSource: "SessionSource";
+    readonly Outcome: "Outcome";
+    readonly DurationMs: "DurationMs";
+    /** Forced to `skills-plugin` by the CLI; a payload cannot set it. */
+    readonly Source: "Source";
+};
+/** Dimensions a packager dependency span carries. */
+export declare const PackagerDimensions: {
+    readonly ProjectId: "ProjectId";
+    readonly ProjectType: "ProjectType";
+    readonly SolutionId: "SolutionId";
+};
+/**
+ * The platform scope a session is pointed at, stamped as defaults rather than
+ * per call. `CloudOrganizationId` / `CloudTenantId` carry the rest of it.
+ */
+export declare const ScopeDimensions: {
+    /**
+     * The selected Orchestrator folder's numeric id. Not in
+     * {@link ID_DIMENSIONS}: digits have no case, so the lowercase pass would
+     * be a no-op on it — unlike `FolderKey`, which is a GUID an API can return
+     * in either case.
+     */
+    readonly FolderId: "FolderId";
+};
+/**
+ * Every dimension whose value is an id, and therefore has to ship lowercase.
+ *
+ * The convention says "Lower Case for all ids" — ids only, not every value.
+ * Lowercasing indiscriminately would turn `UiPath.Cli` into `uipath.cli`,
+ * flatten model slugs, and rewrite the redactor's `[REDACTED]` sentinel into
+ * something a downstream reader would not recognise as redacted.
+ *
+ * `SessionId` is deliberately NOT here. It is the host's handle, shipped
+ * verbatim so a host that exports `UIPATH_SESSION_ID=AbC` can find its own
+ * sessions by that literal string — and it has to keep agreeing with the
+ * native `ai.session.id` tag, which nothing lowercases.
+ */
+export declare const ID_DIMENSIONS: ReadonlySet<string>;
+/**
+ * Key prefixes the PascalCase rule does not apply to.
+ *
+ * - `uip.cmd.arg.` namespaces a command's own option names. The prefix is the
+ *   guarantee that user-supplied keys can never collide with a system dimension
+ *   at the root (see `TELEMETRY_COMMAND_ARG_PREFIX`), and option names are
+ *   kebab-case anyway. PascalCasing them would trade a real safety property for
+ *   a cosmetic one.
+ * - `server.` / `http.` are OpenTelemetry stable semantic conventions, emitted
+ *   only on HTTP dependency spans. Those spans are operational telemetry, which
+ *   the same convention page says does not belong in Snowflake at all; renaming
+ *   them would break OTel and APM tooling for no analytics gain.
+ */
+export declare const DIMENSION_NAME_EXEMPT_PREFIXES: readonly string[];
+/** Whether a dimension key is exempt from the PascalCase rule. */
+export declare function isExemptDimensionName(name: string): boolean;
+/** PascalCase, no separators — the convention's rule for a dimension key. */
+export declare const DIMENSION_NAME_PATTERN: RegExp;
+/**
+ * `[FeatureName].[PerformedAction]` — two PascalCase segments, no more.
+ *
+ * The "no more" is the part worth testing: `Cli.Pull.Failed` satisfies every
+ * casing rule and still fails the convention.
+ */
+export declare const EVENT_NAME_PATTERN: RegExp;
+/** Every dimension name the CLI knows about. */
+export declare const RESERVED_DIMENSION_NAMES: ReadonlySet<string>;
+/**
+ * Dimensions the CLI computes for itself, which no external payload may set.
+ *
+ * `uip track` checks its payload-to-dimension map against this at module load.
+ * The point is identity: a hook that could land a value on `CloudUserId` could
+ * attribute its own events to any user it liked, and the allowlist is the only
+ * path from a payload to a dimension. Failing at startup beats shipping a
+ * spoofed id quietly.
+ *
+ * Two dimensions a hook legitimately fills are deliberately NOT here:
+ *
+ * - `AgentModel` — only the agent knows its own model; the CLI cannot derive it
+ *   from the environment.
+ * - `ToolName` — on a skills event this is the AGENT's tool (`Bash`, `Edit`),
+ *   not the CLI tool bundle the base dimension carries. The two have shared a
+ *   name since before the rename and do not collide in practice, because a
+ *   `uip track` run registers no tool bundle. It is still one name for two
+ *   concepts and is worth splitting; doing it here would have changed a
+ *   dashboard-facing dimension under cover of a casing change, so it is called
+ *   out in `docs/reference/skills-telemetry-events.md` instead.
+ */
+export declare const CURATED_DIMENSIONS: ReadonlySet<string>;
+/**
+ * Fail loudly if an ingestion map would let external input write a dimension
+ * the CLI computes for itself.
+ *
+ * Called at module load by `uip track`, so a map that could attribute a hook's
+ * events to an arbitrary `CloudUserId` breaks the CLI at startup instead of
+ * shipping a spoofed identity quietly. `inputKey` is named in the message
+ * because the map is the only place the mistake can be made.
+ */
+export declare function assertNoCuratedDimensionTargets(map: Readonly<Record<string, string>>, mapName: string): void;
+/**
+ * Lowercase the values of the id dimensions, leaving every other value alone.
+ *
+ * Runs at the emit choke point after the whole bag is assembled, so it applies
+ * to an id whichever layer contributed it.
+ */
+export declare function lowercaseIdDimensionValues<T extends Record<string, string | number | boolean | undefined>>(properties: T): T;

package/dist/telemetry/telemetry-events.d.ts

@@ -1,14 +1,26 @@
 /**
  * Canonical CLI event names.
  *
- * Every name lives under the `uip.*` namespace so a single
- * `name startswith "uip."` filter selects all CLI telemetry — a snake_case
- * name outside it is invisible to every downstream pipeline (STUD-80942).
+ * Every name is `[FeatureName].[PerformedAction]` — two PascalCase segments —
+ * per UiPath's business-telemetry convention (PRENG-7421). `Cli` is the feature
+ * slot for the CLI's own actions. The convention's minimum events keep their
+ * prescribed names (`Application.Start`, `Application.Error`,
+ * `Authenticate.LogIn`), so a cross-product query finds the CLI's rows; filter
+ * on `ApplicationName == "UiPath.Cli"` to pick the CLI out, not on the name.
+ *
+ * A third segment is not a smaller violation than a lowercase name: it fails
+ * the convention just as squarely, so `Cli.ShipSucceeded`, not
+ * `Cli.Ship.Succeeded`.
  */
 export declare const CommonTelemetryEvents: {
-    readonly Error: "uip.error";
+    /** One per run the CLI records: the minimum event for "the app started".
+     * The run's request row carries the command itself. */
+    readonly Start: "Application.Start";
+    /** A command failed. The convention's minimum event for an error, with
+     * `ErrorCode` and `ErrorMessage`. */
+    readonly Error: "Application.Error";
     /** A ship (publish/deploy/upload) completed. The command that shipped is
-     * carried by the `command_name` dimension; `ship_kind`/`target` describe
+     * carried by the `CommandName` dimension; `ShipKind`/`Target` describe
      * what was shipped where. */
-    readonly ShipSucceeded: "uip.ship.succeeded";
+    readonly ShipSucceeded: "Cli.ShipSucceeded";
 };