@uipath/uipath-typescript 1.4.2 → 1.5.0

package/dist/agent-memory/index.d.ts

@@ -329,7 +329,10 @@ interface AgentMemoryGetCallsTimelineOptions extends AgentMemoryFilterOptions {
  * Options for retrieving the top memory spaces.
  */
 interface AgentMemoryGetTopSpacesOptions extends AgentMemoryFilterOptions {
-    /** Maximum number of memory spaces to return, ranked by memory count. Defaults to 5 when omitted. */
+    /**
+     * Maximum number of memory spaces to return, ranked by memory count.
+     * @default 5
+     */
     limit?: number;
 }
 /**

package/dist/agents/index.cjs

@@ -1604,6 +1604,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
  */
@@ -1619,10 +1638,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`,
 };
 
 /**
@@ -1654,6 +1683,33 @@ const sdkClient = coreTelemetry.getOrCreateClient(CLOUD_ROLE_NAME);
 const track = coreTelemetry.createTrack(sdkClient);
 coreTelemetry.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.
  */
@@ -1835,7 +1891,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
@@ -1847,13 +1903,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
@@ -1915,6 +1971,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
@@ -1955,6 +2251,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.
@@ -1967,9 +2278,9 @@ exports.AgentListSortColumn = void 0;
     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";
 })(exports.AgentListSortColumn || (exports.AgentListSortColumn = {}));
@@ -1991,5 +2302,29 @@ exports.AgentErrorSortColumn = void 0;
     AgentErrorSortColumn["LastSeenFolderName"] = "LastSeenFolderName";
     AgentErrorSortColumn["LastSeenFolderPath"] = "LastSeenFolderPath";
 })(exports.AgentErrorSortColumn || (exports.AgentErrorSortColumn = {}));
+/**
+ * Agent type, used to filter consumption results.
+ *
+ * Wire format is the string name, per the API's `StringEnumConverter` serialization.
+ */
+exports.AgentType = void 0;
+(function (AgentType) {
+    AgentType["Autonomous"] = "Autonomous";
+    AgentType["Conversational"] = "Conversational";
+    AgentType["Coded"] = "Coded";
+})(exports.AgentType || (exports.AgentType = {}));
+/**
+ * Job execution mode filter accepted by the summary endpoints.
+ *
+ * Wire format is the string name (`"Debug"` / `"Runtime"`), per the API's
+ * `StringEnumConverter` serialization.
+ */
+exports.AgentExecutionType = void 0;
+(function (AgentExecutionType) {
+    /** Test runs */
+    AgentExecutionType["Debug"] = "Debug";
+    /** Production runs */
+    AgentExecutionType["Runtime"] = "Runtime";
+})(exports.AgentExecutionType || (exports.AgentExecutionType = {}));
 
 exports.Agents = AgentService;