@uipath/uipath-typescript 1.3.2 → 1.3.4

package/dist/jobs/index.cjs

@@ -506,6 +506,8 @@ class ErrorFactory {
 }
 
 const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
+const TRACEPARENT = 'traceparent';
+const UIPATH_TRACEPARENT_ID = 'x-uipath-traceparent-id';
 /**
  * Content type constants for HTTP requests/responses
  */
@@ -559,8 +561,13 @@ class ApiClient {
         if (isFormData) {
             delete defaultHeaders['Content-Type'];
         }
+        const traceId = crypto.randomUUID().replace(/-/g, '');
+        const spanId = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
+        const traceparentValue = `00-${traceId}-${spanId}-01`;
         const headers = {
             ...defaultHeaders,
+            [TRACEPARENT]: traceparentValue,
+            [UIPATH_TRACEPARENT_ID]: traceparentValue,
             ...options.headers
         };
         // Convert params to URLSearchParams
@@ -600,7 +607,11 @@ class ApiClient {
                 const text = await response.text();
                 return text;
             }
-            return response.json();
+            const text = await response.text();
+            if (!text) {
+                return undefined;
+            }
+            return JSON.parse(text);
         }
         catch (error) {
             // If it's already one of our errors, re-throw it
@@ -1232,8 +1243,9 @@ class PaginationHelpers {
             });
         }
         // Extract and transform items from response
-        const rawItems = response.data?.[itemsField];
-        const totalCount = response.data?.[totalCountField];
+        // Handle both plain array responses and envelope responses ({ value: [...], totalRecordCount: N })
+        const rawItems = Array.isArray(response.data) ? response.data : response.data?.[itemsField];
+        const totalCount = Array.isArray(response.data) ? undefined : response.data?.[totalCountField];
         // Parse items - automatically handle JSON string responses
         const parsedItems = typeof rawItems === 'string' ? JSON.parse(rawItems) : (rawItems || []);
         const items = transformFn ? parsedItems.map(transformFn) : parsedItems;
@@ -1484,7 +1496,7 @@ class BaseService {
         const params = this.validateAndPreparePaginationParams(paginationType, paginationOptions);
         // Prepare request parameters based on pagination type
         const requestParams = this.preparePaginationRequestParams(paginationType, params, options.pagination);
-        // For POST requests, merge pagination params into body; for GET, use query params
+        // For POST requests, merge pagination params into body and set params to undefined; for GET, use query params
         if (method.toUpperCase() === 'POST') {
             const existingBody = (options.body && typeof options.body === 'object') ? options.body : {};
             options.body = {
@@ -1492,6 +1504,7 @@ class BaseService {
                 ...options.params,
                 ...requestParams
             };
+            options.params = undefined;
         }
         else {
             // Merge pagination parameters with existing parameters
@@ -1532,7 +1545,6 @@ class BaseService {
                 if (params.pageNumber && params.pageNumber > 1) {
                     requestParams[offsetParam] = (params.pageNumber - 1) * limitedPageSize;
                 }
-                // Include total count for ODATA APIs
                 {
                     requestParams[countParam] = true;
                 }
@@ -1560,8 +1572,9 @@ class BaseService {
         const totalCountField = fields.totalCountField || 'totalRecordCount';
         const continuationTokenField = fields.continuationTokenField || 'continuationToken';
         // Extract items and metadata
-        const items = response.data[itemsField] || [];
-        const totalCount = response.data[totalCountField];
+        // Handle both plain array responses and envelope responses ({ value: [...], totalRecordCount: N })
+        const items = Array.isArray(response.data) ? response.data : (response.data[itemsField] || []);
+        const totalCount = Array.isArray(response.data) ? undefined : response.data[totalCountField];
         const continuationToken = response.data[continuationTokenField];
         // Determine if there are more pages
         const hasMore = this.determineHasMorePages(paginationType, {
@@ -1657,6 +1670,27 @@ function createJobMethods(jobData, service) {
                 throw new Error('Job folderId is undefined');
             return service.getOutput(jobData.key, jobData.folderId);
         },
+        async stop(options) {
+            if (!jobData.key)
+                throw new Error('Job key is undefined');
+            if (!jobData.folderId)
+                throw new Error('Job folderId is undefined');
+            return service.stop([jobData.key], jobData.folderId, options);
+        },
+        async resume(options) {
+            if (!jobData.key)
+                throw new Error('Job key is undefined');
+            if (!jobData.folderId)
+                throw new Error('Job folderId is undefined');
+            return service.resume(jobData.key, jobData.folderId, options);
+        },
+        async restart() {
+            if (!jobData.key)
+                throw new Error('Job key is undefined');
+            if (!jobData.folderId)
+                throw new Error('Job folderId is undefined');
+            return service.restart(jobData.key, jobData.folderId);
+        },
     };
 }
 /**
@@ -1685,6 +1719,9 @@ const ORCHESTRATOR_BASE = 'orchestrator_';
 const JOB_ENDPOINTS = {
     GET_ALL: `${ORCHESTRATOR_BASE}/odata/Jobs`,
     GET_BY_KEY: (identifier) => `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier=${identifier})`,
+    STOP: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StopJobs`,
+    RESUME: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.ResumeJob`,
+    RESTART: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.RestartJob`,
 };
 /**
  * Orchestrator Attachment Service Endpoints
@@ -1693,6 +1730,8 @@ const ORCHESTRATOR_ATTACHMENT_ENDPOINTS = {
     GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Attachments(${id})`,
 };
 
+/** Maximum number of job keys to resolve in a single OData filter query */
+const JOB_KEY_RESOLUTION_CHUNK_SIZE = 50;
 /**
  * Maps fields for Job entities to ensure consistent naming
  * Semantic renames only — case conversion handled by pascalToCamelCaseKeys()
@@ -1714,7 +1753,7 @@ const JobMap = {
 // Connection string placeholder that will be replaced during build
 const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
 // SDK Version placeholder 
-const SDK_VERSION = "1.3.2";
+const SDK_VERSION = "1.3.4";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -2034,6 +2073,182 @@ __decorate([
     track('Attachments.GetById')
 ], AttachmentService.prototype, "getById", null);
 
+/**
+ * Enum for package types
+ */
+var PackageType;
+(function (PackageType) {
+    PackageType["Undefined"] = "Undefined";
+    PackageType["Process"] = "Process";
+    PackageType["ProcessOrchestration"] = "ProcessOrchestration";
+    PackageType["WebApp"] = "WebApp";
+    PackageType["Agent"] = "Agent";
+    PackageType["TestAutomationProcess"] = "TestAutomationProcess";
+    PackageType["Api"] = "Api";
+    PackageType["MCPServer"] = "MCPServer";
+    PackageType["BusinessRules"] = "BusinessRules";
+    PackageType["CaseManagement"] = "CaseManagement";
+    PackageType["Flow"] = "Flow";
+    PackageType["Function"] = "Function";
+})(PackageType || (PackageType = {}));
+/**
+ * Enum for job priority
+ */
+var JobPriority;
+(function (JobPriority) {
+    JobPriority["Low"] = "Low";
+    JobPriority["Normal"] = "Normal";
+    JobPriority["High"] = "High";
+})(JobPriority || (JobPriority = {}));
+/**
+ * Enum for target framework
+ */
+var TargetFramework;
+(function (TargetFramework) {
+    TargetFramework["Legacy"] = "Legacy";
+    TargetFramework["Windows"] = "Windows";
+    TargetFramework["Portable"] = "Portable";
+})(TargetFramework || (TargetFramework = {}));
+/**
+ * Enum for robot size
+ */
+var RobotSize;
+(function (RobotSize) {
+    RobotSize["Small"] = "Small";
+    RobotSize["Standard"] = "Standard";
+    RobotSize["Medium"] = "Medium";
+    RobotSize["Large"] = "Large";
+})(RobotSize || (RobotSize = {}));
+/**
+ * Enum for remote control access
+ */
+var RemoteControlAccess;
+(function (RemoteControlAccess) {
+    RemoteControlAccess["None"] = "None";
+    RemoteControlAccess["ReadOnly"] = "ReadOnly";
+    RemoteControlAccess["Full"] = "Full";
+})(RemoteControlAccess || (RemoteControlAccess = {}));
+/**
+ * Enum for process start strategy
+ */
+var StartStrategy;
+(function (StartStrategy) {
+    StartStrategy["All"] = "All";
+    StartStrategy["Specific"] = "Specific";
+    StartStrategy["RobotCount"] = "RobotCount";
+    StartStrategy["JobsCount"] = "JobsCount";
+    StartStrategy["ModernJobsCount"] = "ModernJobsCount";
+})(StartStrategy || (StartStrategy = {}));
+/**
+ * Enum for package source type
+ */
+var PackageSourceType;
+(function (PackageSourceType) {
+    PackageSourceType["Manual"] = "Manual";
+    PackageSourceType["Schedule"] = "Schedule";
+    PackageSourceType["Queue"] = "Queue";
+    PackageSourceType["StudioWeb"] = "StudioWeb";
+    PackageSourceType["IntegrationTrigger"] = "IntegrationTrigger";
+    PackageSourceType["StudioDesktop"] = "StudioDesktop";
+    PackageSourceType["AutomationOpsPipelines"] = "AutomationOpsPipelines";
+    PackageSourceType["Apps"] = "Apps";
+    PackageSourceType["SAP"] = "SAP";
+    PackageSourceType["HttpTrigger"] = "HttpTrigger";
+    PackageSourceType["HttpTriggerWithCallback"] = "HttpTriggerWithCallback";
+    PackageSourceType["RobotAPI"] = "RobotAPI";
+    PackageSourceType["Assistant"] = "Assistant";
+    PackageSourceType["CommandLine"] = "CommandLine";
+    PackageSourceType["RobotNetAPI"] = "RobotNetAPI";
+    PackageSourceType["Autopilot"] = "Autopilot";
+    PackageSourceType["TestManager"] = "TestManager";
+    PackageSourceType["AgentService"] = "AgentService";
+    PackageSourceType["ProcessOrchestration"] = "ProcessOrchestration";
+    PackageSourceType["PluginEcosystem"] = "PluginEcosystem";
+    PackageSourceType["PerformanceTesting"] = "PerformanceTesting";
+    PackageSourceType["AgentHub"] = "AgentHub";
+    PackageSourceType["ApiWorkflow"] = "ApiWorkflow";
+})(PackageSourceType || (PackageSourceType = {}));
+/**
+ * Enum for job source type
+ */
+var JobSourceType;
+(function (JobSourceType) {
+    JobSourceType["Manual"] = "Manual";
+    JobSourceType["Schedule"] = "Schedule";
+    JobSourceType["Agent"] = "Agent";
+    JobSourceType["Queue"] = "Queue";
+    JobSourceType["StudioWeb"] = "StudioWeb";
+    JobSourceType["IntegrationTrigger"] = "IntegrationTrigger";
+    JobSourceType["StudioDesktop"] = "StudioDesktop";
+    JobSourceType["AutomationOpsPipelines"] = "AutomationOpsPipelines";
+    JobSourceType["Apps"] = "Apps";
+    JobSourceType["SAP"] = "SAP";
+    JobSourceType["HttpTrigger"] = "HttpTrigger";
+    JobSourceType["HttpTriggerCallback"] = "HttpTriggerCallback";
+    JobSourceType["RobotAPI"] = "RobotAPI";
+    JobSourceType["CommandLine"] = "CommandLine";
+    JobSourceType["RobotNetAPI"] = "RobotNetAPI";
+    JobSourceType["Autopilot"] = "Autopilot";
+    JobSourceType["TestManager"] = "TestManager";
+    JobSourceType["AgentService"] = "AgentService";
+    JobSourceType["ProcessOrchestration"] = "ProcessOrchestration";
+    JobSourceType["PluginEcosystem"] = "PluginEcosystem";
+    JobSourceType["PerformanceTesting"] = "PerformanceTesting";
+    JobSourceType["AgentHub"] = "AgentHub";
+    JobSourceType["ApiWorkflow"] = "ApiWorkflow";
+    JobSourceType["CaseManagement"] = "CaseManagement";
+})(JobSourceType || (JobSourceType = {}));
+/**
+ * Enum for stop strategy
+ */
+exports.StopStrategy = void 0;
+(function (StopStrategy) {
+    StopStrategy["SoftStop"] = "SoftStop";
+    StopStrategy["Kill"] = "Kill";
+})(exports.StopStrategy || (exports.StopStrategy = {}));
+/**
+ * Enum for runtime type
+ */
+var RuntimeType;
+(function (RuntimeType) {
+    RuntimeType["NonProduction"] = "NonProduction";
+    RuntimeType["Attended"] = "Attended";
+    RuntimeType["Unattended"] = "Unattended";
+    RuntimeType["Development"] = "Development";
+    RuntimeType["Studio"] = "Studio";
+    RuntimeType["RpaDeveloper"] = "RpaDeveloper";
+    RuntimeType["StudioX"] = "StudioX";
+    RuntimeType["CitizenDeveloper"] = "CitizenDeveloper";
+    RuntimeType["Headless"] = "Headless";
+    RuntimeType["StudioPro"] = "StudioPro";
+    RuntimeType["RpaDeveloperPro"] = "RpaDeveloperPro";
+    RuntimeType["TestAutomation"] = "TestAutomation";
+    RuntimeType["AutomationCloud"] = "AutomationCloud";
+    RuntimeType["Serverless"] = "Serverless";
+    RuntimeType["AutomationKit"] = "AutomationKit";
+    RuntimeType["ServerlessTestAutomation"] = "ServerlessTestAutomation";
+    RuntimeType["AutomationCloudTestAutomation"] = "AutomationCloudTestAutomation";
+    RuntimeType["AttendedStudioWeb"] = "AttendedStudioWeb";
+    RuntimeType["Hosting"] = "Hosting";
+    RuntimeType["AssistantWeb"] = "AssistantWeb";
+    RuntimeType["ProcessOrchestration"] = "ProcessOrchestration";
+    RuntimeType["AgentService"] = "AgentService";
+    RuntimeType["AppTest"] = "AppTest";
+    RuntimeType["PerformanceTest"] = "PerformanceTest";
+    RuntimeType["BusinessRule"] = "BusinessRule";
+    RuntimeType["CaseManagement"] = "CaseManagement";
+    RuntimeType["Flow"] = "Flow";
+})(RuntimeType || (RuntimeType = {}));
+/**
+ * Enum for job type
+ */
+var JobType;
+(function (JobType) {
+    JobType["Unattended"] = "Unattended";
+    JobType["Attended"] = "Attended";
+    JobType["ServerlessGeneric"] = "ServerlessGeneric";
+})(JobType || (JobType = {}));
+
 /**
  * Service for interacting with UiPath Orchestrator Jobs API
  */
@@ -2203,6 +2418,121 @@ class JobService extends FolderScopedService {
         }
         return null;
     }
+    /**
+     * Stops one or more jobs by their UUID keys.
+     *
+     * Sends a stop request for the specified jobs to the Orchestrator. Throws if any keys cannot be resolved.
+     *
+     * @param jobKeys - Array of job UUID keys to stop (e.g., from {@link JobGetResponse}.key)
+     * @param folderId - The folder ID where the jobs reside (required)
+     * @param options - Optional {@link JobStopOptions} including stop strategy
+     * @returns Promise that resolves when the jobs are stopped successfully, or rejects on failure
+     *
+     * @example
+     * ```typescript
+     * // Stop a single job with default soft stop
+     * await jobs.stop([<jobKey>], <folderId>);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * import { StopStrategy } from '@uipath/uipath-typescript/jobs';
+     *
+     * // Force-kill multiple jobs
+     * await jobs.stop(
+     *   [<jobKey1>, <jobKey2>],
+     *   <folderId>,
+     *   { strategy: StopStrategy.Kill }
+     * );
+     * ```
+     */
+    async stop(jobKeys, folderId, options) {
+        if (jobKeys.length === 0) {
+            return;
+        }
+        if (!folderId) {
+            throw new ValidationError({ message: 'folderId is required for stop' });
+        }
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        const strategy = options?.strategy ?? exports.StopStrategy.SoftStop;
+        const jobIds = await this.resolveJobKeys(jobKeys, folderId);
+        await this.stopJobsByIds(jobIds, strategy, headers);
+    }
+    /**
+     * Resumes a suspended job.
+     *
+     * Sends a resume request to a job that is currently in the `Suspended` state.
+     * The job transitions to `Resumed` and then to `Running` as it continues execution. Optionally pass
+     * input arguments to provide data for the resumed workflow.
+     *
+     * @param jobKey - The unique key (GUID) of the suspended job to resume
+     * @param folderId - The folder ID where the job resides
+     * @param options - Optional parameters including input arguments
+     * @returns Promise that resolves when the job is resumed successfully, or rejects on failure
+     *
+     * @example
+     * ```typescript
+     * // Resume a suspended job
+     * await jobs.resume(<jobKey>, <folderId>);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Resume with input arguments
+     * await jobs.resume(<jobKey>, <folderId>, {
+     *   inputArguments: { approved: true }
+     * });
+     * ```
+     */
+    async resume(jobKey, folderId, options) {
+        if (!jobKey) {
+            throw new ValidationError({ message: 'jobKey is required for resume' });
+        }
+        if (!folderId) {
+            throw new ValidationError({ message: 'folderId is required for resume' });
+        }
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        const body = { jobKey };
+        if (options?.inputArguments) {
+            body.inputArguments = JSON.stringify(options.inputArguments);
+        }
+        await this.post(JOB_ENDPOINTS.RESUME, body, { headers });
+    }
+    /**
+     * Restarts a job in a final state (Successful, Faulted, or Stopped).
+     *
+     * Creates a **new** job execution from a previously successful, faulted, or stopped job.
+     * The new job has its own unique `key`, starts in `Pending` state, and uses
+     * the same process and input arguments as the original job.
+     *
+     * To monitor the new job's progress, poll with {@link getById}
+     * using the returned job's key until the state reaches a final value.
+     *
+     * @param jobKey - The unique key (GUID) of the job to restart
+     * @param folderId - The folder ID where the job resides
+     * @returns Promise resolving to the new {@link JobGetResponse} with full job details
+     *
+     * @example
+     * ```typescript
+     * // Restart a faulted job
+     * const newJob = await jobs.restart(<jobKey>, <folderId>);
+     * console.log(newJob.state); // 'Pending'
+     * console.log(newJob.key);   // new job key (different from original)
+     * ```
+     */
+    async restart(jobKey, folderId) {
+        if (!jobKey) {
+            throw new ValidationError({ message: 'jobKey is required for restart' });
+        }
+        if (!folderId) {
+            throw new ValidationError({ message: 'folderId is required for restart' });
+        }
+        const [jobId] = await this.resolveJobKeys([jobKey], folderId);
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        const response = await this.post(JOB_ENDPOINTS.RESTART, { jobId }, { headers });
+        const rawJob = transformData(pascalToCamelCaseKeys(response.data), JobMap);
+        return createJobWithMethods(rawJob, this);
+    }
     /**
      * Downloads the output file content via the Attachments API.
      * 1. Fetches blob access info from the attachment using AttachmentService
@@ -2237,6 +2567,43 @@ class JobService extends FolderScopedService {
             throw new ServerError({ message: 'Failed to parse job output file as JSON' });
         }
     }
+    /**
+     * Resolves job UUID keys to integer IDs via the getAll method.
+     * Chunks keys into batches to avoid URL length limits.
+     */
+    async resolveJobKeys(jobKeys, folderId) {
+        const uniqueKeys = [...new Set(jobKeys)];
+        const keyToIdMap = new Map();
+        const chunks = [];
+        for (let i = 0; i < uniqueKeys.length; i += JOB_KEY_RESOLUTION_CHUNK_SIZE) {
+            chunks.push(uniqueKeys.slice(i, i + JOB_KEY_RESOLUTION_CHUNK_SIZE));
+        }
+        const results = await Promise.all(chunks.map((chunk) => {
+            const filterValues = chunk.map((key) => `'${key}'`).join(',');
+            return this.getAll({
+                folderId,
+                filter: `key in (${filterValues})`,
+                select: 'id,key',
+                pageSize: chunk.length,
+            });
+        }));
+        for (const response of results) {
+            for (const job of response.items) {
+                keyToIdMap.set(job.key, job.id);
+            }
+        }
+        const missingKeys = uniqueKeys.filter((key) => !keyToIdMap.has(key));
+        if (missingKeys.length > 0) {
+            throw new ValidationError({ message: `Jobs not found for keys: ${missingKeys.join(', ')}` });
+        }
+        return uniqueKeys.map((key) => keyToIdMap.get(key));
+    }
+    /**
+     * Calls the StopJobs OData action with resolved integer IDs.
+     */
+    async stopJobsByIds(jobIds, strategy, headers) {
+        await this.post(JOB_ENDPOINTS.STOP, { jobIds, strategy }, { headers });
+    }
 }
 __decorate([
     track('Jobs.GetAll')
@@ -2247,6 +2614,15 @@ __decorate([
 __decorate([
     track('Jobs.GetOutput')
 ], JobService.prototype, "getOutput", null);
+__decorate([
+    track('Jobs.Stop')
+], JobService.prototype, "stop", null);
+__decorate([
+    track('Jobs.Resume')
+], JobService.prototype, "resume", null);
+__decorate([
+    track('Jobs.Restart')
+], JobService.prototype, "restart", null);
 
 /**
  * Enum for job sub-state