@uipath/uipath-typescript 1.4.1 → 1.5.0

package/dist/agents/index.mjs

@@ -1602,6 +1602,25 @@ class BaseService {
 }
 _BaseService_apiClient = new WeakMap();
 
+/**
+ * Common enum for job state used across services
+ */
+var JobState;
+(function (JobState) {
+    JobState["Pending"] = "Pending";
+    JobState["Running"] = "Running";
+    JobState["Stopping"] = "Stopping";
+    JobState["Terminating"] = "Terminating";
+    JobState["Faulted"] = "Faulted";
+    JobState["Successful"] = "Successful";
+    JobState["Stopped"] = "Stopped";
+    JobState["Suspended"] = "Suspended";
+    JobState["Resumed"] = "Resumed";
+    JobState["Cancelled"] = "Cancelled";
+    /** Server-side fallback for an unrecognized or missing job state. */
+    JobState["Unknown"] = "Unknown";
+})(JobState || (JobState = {}));
+
 /**
  * Base path constants for different services
  */
@@ -1617,10 +1636,20 @@ const AGENTS_ENDPOINTS = {
     GET_INCIDENTS: `${INSIGHTS_RTM_BASE}/Agents/incidents`,
     /** Time-series of error counts grouped by agent over the requested window. */
     GET_ERRORS_TIMELINE: `${INSIGHTS_RTM_BASE}/Agents/errors`,
-    /** Time-series of AGU consumption over the requested window. */
+    /** Time-series of Agent Units consumption over the requested window. */
     GET_CONSUMPTION_TIMELINE: `${INSIGHTS_RTM_BASE}/Agents/consumptionTimeline`,
     /** Time-series of agent latency (per-percentile) over the requested window. */
     GET_LATENCY_TIMELINE: `${INSIGHTS_RTM_BASE}/Agents/latencyTimeline`,
+    /** Top-N agents by error count over the requested window. */
+    GET_TOP_ERROR_COUNT: `${INSIGHTS_RTM_BASE}/Agents/topErroredAgents`,
+    /** Top-N agents by unit consumption over the requested window. */
+    GET_TOP_CONSUMPTION: `${INSIGHTS_RTM_BASE}/Agents/consumption`,
+    /** Distribution of incidents across types (errors, escalations, policy). */
+    GET_INCIDENT_DISTRIBUTION: `${INSIGHTS_RTM_BASE}/Agents/incidentDistribution`,
+    /** Aggregate per-agent and overall job/success/duration summary over the requested window. */
+    GET_SUMMARY: `${INSIGHTS_RTM_BASE}/Agents/summary`,
+    /** Aggregate Agent Units and Platform Units consumption per agent over the requested window. */
+    GET_UNIT_CONSUMPTION_SUMMARY: `${INSIGHTS_RTM_BASE}/Agents/summary/unit-consumption`,
 };
 
 /**
@@ -1652,6 +1681,33 @@ const sdkClient = getOrCreateClient(CLOUD_ROLE_NAME);
 const track = createTrack(sdkClient);
 createTrackEvent(sdkClient);
 
+const JOB_STATUS_ALIASES = {
+    Success: JobState.Successful,
+};
+const VALID_JOB_STATES = new Set(Object.values(JobState));
+/**
+ * Permissively maps a raw `lastJobStatus` string to a {@link JobState}. Known
+ * aliases are translated first, canonical values pass through, and anything
+ * unrecognized falls back to {@link JobState.Unknown} rather than throwing.
+ */
+function toJobState(raw) {
+    if (Object.prototype.hasOwnProperty.call(JOB_STATUS_ALIASES, raw))
+        return JOB_STATUS_ALIASES[raw];
+    if (VALID_JOB_STATES.has(raw))
+        return raw;
+    return JobState.Unknown;
+}
+/**
+ * Transforms a raw summary period into the public shape, normalizing every
+ * agent's raw `lastJobStatus` string to a {@link JobState}. Tolerates a missing
+ * `agents` array (treated as empty).
+ */
+function normalizeSummaryPeriod(period) {
+    return {
+        ...period,
+        agents: (period.agents ?? []).map((agent) => ({ ...agent, lastJobStatus: toJobState(agent.lastJobStatus) })),
+    };
+}
 /**
  * Service for interacting with the UiPath Agents API.
  */
@@ -1833,7 +1889,7 @@ class AgentService extends BaseService {
         return response.data.data;
     }
     /**
-     * Retrieves a time-series of AGU (Agent Units) consumption over the requested window.
+     * Retrieves a time-series of Agent Units consumption over the requested window.
      *
      * @param startTime - Inclusive lower bound for the query window
      * @param endTime - Exclusive upper bound for the query window
@@ -1845,13 +1901,13 @@ class AgentService extends BaseService {
      *
      * const agents = new Agents(sdk);
      *
-     * // AGU consumption timeline in May 2025
+     * // Agent Units consumption timeline in May 2025
      * const result = await agents.getConsumptionTimeline(
      *   new Date('2025-05-01T00:00:00Z'),
      *   new Date('2025-06-01T00:00:00Z'),
      * );
      * result.forEach((point) => {
-     *   console.log(`${point.timeSlice}: ${point.aguConsumption} AGU`);
+     *   console.log(`${point.timeSlice}: ${point.aguConsumption} Agent Units`);
      * });
      * ```
      * @example
@@ -1913,6 +1969,246 @@ class AgentService extends BaseService {
         const response = await this.post(AGENTS_ENDPOINTS.GET_LATENCY_TIMELINE, body);
         return response.data.data;
     }
+    /**
+     * Retrieves the top-N agents ranked by error count over the requested window.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetTopErrorCountResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Top agents by error count in May 2025
+     * const result = await agents.getTopErrorCount(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * result.data.forEach((agent) => {
+     *   console.log(`${agent.name}: ${agent.count} errors`);
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * // Scope to specific folders and top 5 agents
+     * const result = await agents.getTopErrorCount(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     folderKeys: ['<folderKey1>'],
+     *     limit: 5,
+     *   },
+     * );
+     * ```
+     */
+    async getTopErrorCount(startTime, endTime, options) {
+        const body = this.buildAgentFilterBody(startTime, endTime, options);
+        const response = await this.post(AGENTS_ENDPOINTS.GET_TOP_ERROR_COUNT, body);
+        return response.data;
+    }
+    /**
+     * Retrieves the top-N agents ranked by unit consumption over the requested window.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetTopConsumptionResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Top agents by consumption in May 2025
+     * const result = await agents.getTopConsumption(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * console.log(`Total consumed: ${result.totalConsumed}`);
+     * result.agents.forEach((agent) => {
+     *   console.log(`${agent.agentName}: ${agent.consumedQuantity}`);
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * import { Agents, AgentType } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Top 5 healthy autonomous agents by consumption
+     * const result = await agents.getTopConsumption(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     limit: 5,
+     *     healthy: true,
+     *     agentTypes: [AgentType.Autonomous],
+     *   },
+     * );
+     * ```
+     */
+    async getTopConsumption(startTime, endTime, options) {
+        const body = this.buildAgentFilterBody(startTime, endTime, options);
+        if (options?.healthy !== undefined)
+            body.healthy = options.healthy;
+        if (options?.healthThreshold !== undefined)
+            body.healthThreshold = options.healthThreshold;
+        if (options?.agentTypes?.length)
+            body.agentTypes = options.agentTypes.join(',');
+        const response = await this.post(AGENTS_ENDPOINTS.GET_TOP_CONSUMPTION, body);
+        return response.data.data;
+    }
+    /**
+     * Retrieves breakdown of agent incidents count — errors, escalations,
+     * and policy violations over a requested window.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetIncidentDistributionResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Incident distribution in May 2025
+     * const result = await agents.getIncidentDistribution(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * console.log(`Errors: ${result.errorCount}, Escalations: ${result.escalationCount}, Policy: ${result.policyCount}`);
+     * ```
+     * @example
+     * ```typescript
+     * // Scope to specific folders
+     * const result = await agents.getIncidentDistribution(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     folderKeys: ['<folderKey1>'],
+     *   },
+     * );
+     * ```
+     */
+    async getIncidentDistribution(startTime, endTime, options) {
+        const body = this.buildAgentFilterBody(startTime, endTime, options);
+        const response = await this.post(AGENTS_ENDPOINTS.GET_INCIDENT_DISTRIBUTION, body);
+        return response.data.data;
+    }
+    /**
+     * Retrieves a job-execution summary for the requested window: overall totals
+     * (total jobs, successful jobs, success rate, average duration) alongside a
+     * per-agent breakdown. When `lookbackPeriodAnalysis` is enabled, a comparable
+     * summary for the preceding window of equal length is included too.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetSummaryResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Summary for May 2025
+     * const result = await agents.getSummary(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * console.log(`Success rate: ${result.currentPeriodSummary.successRate}%`);
+     * ```
+     * @example
+     * ```typescript
+     * import { Agents, AgentExecutionType } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Runtime-only summary with lookback comparison
+     * const result = await agents.getSummary(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     lookbackPeriodAnalysis: true,
+     *     executionType: AgentExecutionType.Runtime,
+     *   },
+     * );
+     * ```
+     */
+    async getSummary(startTime, endTime, options) {
+        const body = this.buildAgentFilterBody(startTime, endTime, options);
+        if (options?.lookbackPeriodAnalysis !== undefined)
+            body.lookbackPeriodAnalysis = options.lookbackPeriodAnalysis;
+        if (options?.processKey !== undefined)
+            body.processKey = options.processKey;
+        if (options?.folderKey !== undefined)
+            body.folderKey = options.folderKey;
+        if (options?.executionType !== undefined)
+            body.executionType = options.executionType;
+        const response = await this.post(AGENTS_ENDPOINTS.GET_SUMMARY, body);
+        const summary = response.data.data;
+        return {
+            currentPeriodSummary: normalizeSummaryPeriod(summary.currentPeriodSummary),
+            lookbackPeriodSummary: summary.lookbackPeriodSummary
+                ? normalizeSummaryPeriod(summary.lookbackPeriodSummary)
+                : undefined,
+        };
+    }
+    /**
+     * Retrieves an aggregate Agent Units and Platform Units consumption summary per agent over the
+     * requested window.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetUnitConsumptionSummaryResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Unit consumption summary for May 2025
+     * const result = await agents.getUnitConsumptionSummary(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * console.log(`Agent Units complete jobs: ${result.currentPeriodSummary.totalAgentUnitConsumption.completeJobs}`);
+     * ```
+     * @example
+     * ```typescript
+     * import { Agents, AgentExecutionType } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Runtime-only summary with lookback comparison
+     * const result = await agents.getUnitConsumptionSummary(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     lookbackPeriodAnalysis: true,
+     *     executionType: AgentExecutionType.Runtime,
+     *   },
+     * );
+     * ```
+     */
+    async getUnitConsumptionSummary(startTime, endTime, options) {
+        const body = this.buildAgentFilterBody(startTime, endTime, options);
+        if (options?.lookbackPeriodAnalysis !== undefined)
+            body.lookbackPeriodAnalysis = options.lookbackPeriodAnalysis;
+        if (options?.processKey !== undefined)
+            body.processKey = options.processKey;
+        if (options?.folderKey !== undefined)
+            body.folderKey = options.folderKey;
+        if (options?.executionType !== undefined)
+            body.executionType = options.executionType;
+        const response = await this.post(AGENTS_ENDPOINTS.GET_UNIT_CONSUMPTION_SUMMARY, body);
+        return response.data.data;
+    }
     /**
      * Builds the common POST request body shared by the agent filter endpoints —
      * the required time window plus any optional folder/agent/project/process
@@ -1953,6 +2249,21 @@ __decorate([
 __decorate([
     track('Agents.GetLatencyTimeline')
 ], AgentService.prototype, "getLatencyTimeline", null);
+__decorate([
+    track('Agents.GetTopErrorCount')
+], AgentService.prototype, "getTopErrorCount", null);
+__decorate([
+    track('Agents.GetTopConsumption')
+], AgentService.prototype, "getTopConsumption", null);
+__decorate([
+    track('Agents.GetIncidentDistribution')
+], AgentService.prototype, "getIncidentDistribution", null);
+__decorate([
+    track('Agents.GetSummary')
+], AgentService.prototype, "getSummary", null);
+__decorate([
+    track('Agents.GetUnitConsumptionSummary')
+], AgentService.prototype, "getUnitConsumptionSummary", null);
 
 /**
  * Columns available for ordering results.
@@ -1965,9 +2276,9 @@ var AgentListSortColumn;
     AgentListSortColumn["HealthScore"] = "HealthScore";
     AgentListSortColumn["LastIncident"] = "LastIncident";
     AgentListSortColumn["FolderName"] = "FolderName";
-    /** Quantity of AGU (Agent Units) consumed */
+    /** Quantity of Agent Units consumed */
     AgentListSortColumn["QuantityAGU"] = "QuantityAGU";
-    /** Quantity of PLTU (Platform Units) consumed */
+    /** Quantity of Platform Units consumed */
     AgentListSortColumn["QuantityPLTU"] = "QuantityPLTU";
     AgentListSortColumn["FolderPath"] = "FolderPath";
 })(AgentListSortColumn || (AgentListSortColumn = {}));
@@ -1989,5 +2300,29 @@ var AgentErrorSortColumn;
     AgentErrorSortColumn["LastSeenFolderName"] = "LastSeenFolderName";
     AgentErrorSortColumn["LastSeenFolderPath"] = "LastSeenFolderPath";
 })(AgentErrorSortColumn || (AgentErrorSortColumn = {}));
+/**
+ * Agent type, used to filter consumption results.
+ *
+ * Wire format is the string name, per the API's `StringEnumConverter` serialization.
+ */
+var AgentType;
+(function (AgentType) {
+    AgentType["Autonomous"] = "Autonomous";
+    AgentType["Conversational"] = "Conversational";
+    AgentType["Coded"] = "Coded";
+})(AgentType || (AgentType = {}));
+/**
+ * Job execution mode filter accepted by the summary endpoints.
+ *
+ * Wire format is the string name (`"Debug"` / `"Runtime"`), per the API's
+ * `StringEnumConverter` serialization.
+ */
+var AgentExecutionType;
+(function (AgentExecutionType) {
+    /** Test runs */
+    AgentExecutionType["Debug"] = "Debug";
+    /** Production runs */
+    AgentExecutionType["Runtime"] = "Runtime";
+})(AgentExecutionType || (AgentExecutionType = {}));
 
-export { AgentErrorSortColumn, AgentListSortColumn, AgentService as Agents };
+export { AgentErrorSortColumn, AgentExecutionType, AgentListSortColumn, AgentType, AgentService as Agents };

package/dist/assets/index.cjs

@@ -956,7 +956,16 @@ const BUCKET_TOKEN_PARAMS = {
  * Returns the original value if parsing fails.
  */
 /**
- * Transforms data by mapping fields according to the provided field mapping
+ * Transforms data by renaming each key in `data` exactly once, using the
+ * mapping (`sourceField → targetField`). Keys not present in the mapping
+ * pass through unchanged. The original (pre-rename) key is dropped — the
+ * result contains only the renamed key.
+ *
+ * Each rename is independent. If the mapping happens to contain chained
+ * entries (`a → b` and `b → c`), they do NOT compose: a field named `a`
+ * in `data` becomes `b` (not `c`), because the renames are applied based
+ * on the original data's keys, not the running result.
+ *
  * @param data The source data to transform
  * @param fieldMapping Object mapping source field names to target field names
  * @returns Transformed data with mapped field names
@@ -979,21 +988,28 @@ const BUCKET_TOKEN_PARAMS = {
  * //   { userId: '123', name: 'john' },
  * //   { userId: '456', name: 'jane' }
  * // ]
+ *
+ * // No chaining — `a → b` does not become `a → c` even if the map has `b → c`.
+ * transformData({ a: 1 }, { a: 'b', b: 'c' });
+ * // result = { b: 1 }
  * ```
  */
 function transformData(data, fieldMapping) {
+    // Pass null/undefined through unchanged — callers (e.g. AttachmentService.getById)
+    // may invoke this on optional fields that an OData `select` excluded.
+    if (data == null) {
+        return data;
+    }
     // Handle array of objects
     if (Array.isArray(data)) {
         return data.map(item => transformData(item, fieldMapping));
     }
-    // Handle single object
-    const result = { ...data };
-    for (const [sourceField, targetField] of Object.entries(fieldMapping)) {
-        if (sourceField in result) {
-            const value = result[sourceField];
-            delete result[sourceField];
-            result[targetField] = value;
-        }
+    // Walk the ORIGINAL data's keys, look up each in the mapping. One rename
+    // per data key — no mutation of an in-progress result, so chains can't form.
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const renamedKey = fieldMapping[key] ?? key;
+        result[renamedKey] = value;
     }
     return result;
 }

package/dist/assets/index.mjs

@@ -954,7 +954,16 @@ const BUCKET_TOKEN_PARAMS = {
  * Returns the original value if parsing fails.
  */
 /**
- * Transforms data by mapping fields according to the provided field mapping
+ * Transforms data by renaming each key in `data` exactly once, using the
+ * mapping (`sourceField → targetField`). Keys not present in the mapping
+ * pass through unchanged. The original (pre-rename) key is dropped — the
+ * result contains only the renamed key.
+ *
+ * Each rename is independent. If the mapping happens to contain chained
+ * entries (`a → b` and `b → c`), they do NOT compose: a field named `a`
+ * in `data` becomes `b` (not `c`), because the renames are applied based
+ * on the original data's keys, not the running result.
+ *
  * @param data The source data to transform
  * @param fieldMapping Object mapping source field names to target field names
  * @returns Transformed data with mapped field names
@@ -977,21 +986,28 @@ const BUCKET_TOKEN_PARAMS = {
  * //   { userId: '123', name: 'john' },
  * //   { userId: '456', name: 'jane' }
  * // ]
+ *
+ * // No chaining — `a → b` does not become `a → c` even if the map has `b → c`.
+ * transformData({ a: 1 }, { a: 'b', b: 'c' });
+ * // result = { b: 1 }
  * ```
  */
 function transformData(data, fieldMapping) {
+    // Pass null/undefined through unchanged — callers (e.g. AttachmentService.getById)
+    // may invoke this on optional fields that an OData `select` excluded.
+    if (data == null) {
+        return data;
+    }
     // Handle array of objects
     if (Array.isArray(data)) {
         return data.map(item => transformData(item, fieldMapping));
     }
-    // Handle single object
-    const result = { ...data };
-    for (const [sourceField, targetField] of Object.entries(fieldMapping)) {
-        if (sourceField in result) {
-            const value = result[sourceField];
-            delete result[sourceField];
-            result[targetField] = value;
-        }
+    // Walk the ORIGINAL data's keys, look up each in the mapping. One rename
+    // per data key — no mutation of an in-progress result, so chains can't form.
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const renamedKey = fieldMapping[key] ?? key;
+        result[renamedKey] = value;
     }
     return result;
 }

package/dist/attachments/index.cjs

@@ -277,7 +277,16 @@ class NetworkError extends UiPathError {
  * Returns the original value if parsing fails.
  */
 /**
- * Transforms data by mapping fields according to the provided field mapping
+ * Transforms data by renaming each key in `data` exactly once, using the
+ * mapping (`sourceField → targetField`). Keys not present in the mapping
+ * pass through unchanged. The original (pre-rename) key is dropped — the
+ * result contains only the renamed key.
+ *
+ * Each rename is independent. If the mapping happens to contain chained
+ * entries (`a → b` and `b → c`), they do NOT compose: a field named `a`
+ * in `data` becomes `b` (not `c`), because the renames are applied based
+ * on the original data's keys, not the running result.
+ *
  * @param data The source data to transform
  * @param fieldMapping Object mapping source field names to target field names
  * @returns Transformed data with mapped field names
@@ -300,21 +309,28 @@ class NetworkError extends UiPathError {
  * //   { userId: '123', name: 'john' },
  * //   { userId: '456', name: 'jane' }
  * // ]
+ *
+ * // No chaining — `a → b` does not become `a → c` even if the map has `b → c`.
+ * transformData({ a: 1 }, { a: 'b', b: 'c' });
+ * // result = { b: 1 }
  * ```
  */
 function transformData(data, fieldMapping) {
+    // Pass null/undefined through unchanged — callers (e.g. AttachmentService.getById)
+    // may invoke this on optional fields that an OData `select` excluded.
+    if (data == null) {
+        return data;
+    }
     // Handle array of objects
     if (Array.isArray(data)) {
         return data.map(item => transformData(item, fieldMapping));
     }
-    // Handle single object
-    const result = { ...data };
-    for (const [sourceField, targetField] of Object.entries(fieldMapping)) {
-        if (sourceField in result) {
-            const value = result[sourceField];
-            delete result[sourceField];
-            result[targetField] = value;
-        }
+    // Walk the ORIGINAL data's keys, look up each in the mapping. One rename
+    // per data key — no mutation of an in-progress result, so chains can't form.
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const renamedKey = fieldMapping[key] ?? key;
+        result[renamedKey] = value;
     }
     return result;
 }

package/dist/attachments/index.mjs

@@ -275,7 +275,16 @@ class NetworkError extends UiPathError {
  * Returns the original value if parsing fails.
  */
 /**
- * Transforms data by mapping fields according to the provided field mapping
+ * Transforms data by renaming each key in `data` exactly once, using the
+ * mapping (`sourceField → targetField`). Keys not present in the mapping
+ * pass through unchanged. The original (pre-rename) key is dropped — the
+ * result contains only the renamed key.
+ *
+ * Each rename is independent. If the mapping happens to contain chained
+ * entries (`a → b` and `b → c`), they do NOT compose: a field named `a`
+ * in `data` becomes `b` (not `c`), because the renames are applied based
+ * on the original data's keys, not the running result.
+ *
  * @param data The source data to transform
  * @param fieldMapping Object mapping source field names to target field names
  * @returns Transformed data with mapped field names
@@ -298,21 +307,28 @@ class NetworkError extends UiPathError {
  * //   { userId: '123', name: 'john' },
  * //   { userId: '456', name: 'jane' }
  * // ]
+ *
+ * // No chaining — `a → b` does not become `a → c` even if the map has `b → c`.
+ * transformData({ a: 1 }, { a: 'b', b: 'c' });
+ * // result = { b: 1 }
  * ```
  */
 function transformData(data, fieldMapping) {
+    // Pass null/undefined through unchanged — callers (e.g. AttachmentService.getById)
+    // may invoke this on optional fields that an OData `select` excluded.
+    if (data == null) {
+        return data;
+    }
     // Handle array of objects
     if (Array.isArray(data)) {
         return data.map(item => transformData(item, fieldMapping));
     }
-    // Handle single object
-    const result = { ...data };
-    for (const [sourceField, targetField] of Object.entries(fieldMapping)) {
-        if (sourceField in result) {
-            const value = result[sourceField];
-            delete result[sourceField];
-            result[targetField] = value;
-        }
+    // Walk the ORIGINAL data's keys, look up each in the mapping. One rename
+    // per data key — no mutation of an in-progress result, so chains can't form.
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const renamedKey = fieldMapping[key] ?? key;
+        result[renamedKey] = value;
     }
     return result;
 }