@uipath/maestro-tool 1.202.2 → 1.203.0-preview.180

package/dist/packager-tool-x92czn5x.js

@@ -0,0 +1,208 @@
+import {
+  isRecord
+} from "./packager-tool-mfrdmqmt.js";
+
+// ../flow-tool/src/services/flow-eval-run-readers.ts
+function asRecordArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} response must be an array`);
+  }
+  return value.map((item, index) => {
+    if (!isRecord(item)) {
+      throw new Error(`${label} response item ${index} must be an object`);
+    }
+    return item;
+  });
+}
+function readRecord(value) {
+  return isRecord(value) ? value : undefined;
+}
+function readRecordArray(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  return value.filter(isRecord);
+}
+function optionalNumber(value) {
+  return typeof value === "number" ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : "";
+}
+function statusString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    const statusByCode = {
+      0: "Pending",
+      1: "Running",
+      2: "Completed",
+      3: "PartiallyCompleted",
+      4: "Failed"
+    };
+    return statusByCode[value] ?? String(value);
+  }
+  return "";
+}
+function readEvaluatorScores(value) {
+  const records = readRecordArray(value);
+  if (!records) {
+    return null;
+  }
+  return records.flatMap((score) => {
+    const evaluatorId = score.evaluatorId;
+    const scoreValue = score.value;
+    if (typeof evaluatorId !== "string" || typeof scoreValue !== "number") {
+      return [];
+    }
+    return [{ evaluatorId, value: scoreValue }];
+  });
+}
+function readRemoteEvalSetRun(record) {
+  return {
+    id: optionalString(record.id),
+    workloadId: optionalString(record.workloadId),
+    evalSetId: typeof record.evalSetId === "string" ? record.evalSetId : null,
+    status: statusString(record.status),
+    score: optionalNumber(record.score),
+    evaluatorScores: readEvaluatorScores(record.evaluatorScores),
+    config: readRecord(record.config) ?? {},
+    numberOfEvalsExecuted: optionalNumber(record.numberOfEvalsExecuted),
+    durationMilliseconds: optionalNumber(record.durationMilliseconds),
+    createdAt: optionalString(record.createdAt),
+    updatedAt: optionalString(record.updatedAt)
+  };
+}
+function readRemoteEvalRun(record) {
+  const snapshot = readRecord(record.evalSnapshot);
+  const result = readRecord(record.result);
+  return {
+    id: optionalString(record.id),
+    evalSetRunId: optionalString(record.evalSetRunId),
+    evalSnapshot: snapshot ? {
+      id: typeof snapshot.id === "string" ? snapshot.id : undefined,
+      name: typeof snapshot.name === "string" ? snapshot.name : undefined,
+      inputs: readRecord(snapshot.inputs),
+      evaluationCriterias: readRecord(snapshot.evaluationCriterias),
+      expectedOutput: readRecord(snapshot.expectedOutput) ?? (snapshot.expectedOutput === null ? null : undefined)
+    } : undefined,
+    status: statusString(record.status),
+    result: result ? {
+      output: readRecord(result.output),
+      scores: readEvaluatorScores(result.scores) ?? undefined,
+      score: readRecord(result.score)
+    } : null,
+    completionMetrics: readRecord(record.completionMetrics),
+    evaluatorRuns: readRecordArray(record.evaluatorRuns)?.flatMap((evaluatorRun) => {
+      const evaluatorId = evaluatorRun.evaluatorId;
+      if (typeof evaluatorId !== "string") {
+        return [];
+      }
+      const evaluatorResult = readRecord(evaluatorRun.result);
+      return [
+        {
+          evaluatorId,
+          evaluatorSnapshot: evaluatorRun.evaluatorSnapshot,
+          status: typeof evaluatorRun.status === "string" ? evaluatorRun.status : undefined,
+          result: evaluatorResult ? {
+            output: readRecord(evaluatorResult.output),
+            score: readRecord(evaluatorResult.score)
+          } : null,
+          completionMetrics: readRecord(evaluatorRun.completionMetrics)
+        }
+      ];
+    }),
+    error: typeof record.error === "string" || isRecord(record.error) ? record.error : null,
+    errorMessage: typeof record.errorMessage === "string" ? record.errorMessage : null,
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : undefined,
+    updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : undefined
+  };
+}
+
+// ../flow-tool/src/services/flow-eval-run-api.ts
+var METADATA_FETCH_TIMEOUT_MS = 30000;
+var MAX_ERROR_BODY_LENGTH = 400;
+
+class FlowEvalRunApi {
+  async executeAndEvaluate(config, payload) {
+    return this.requestJson(config, "/unifiedEvals/workloads/executeAndEvaluate", {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+  }
+  async listEvalSetRuns(config, workloadId) {
+    const response = await this.requestJson(config, `/unifiedEvals/workloads/${encodeURIComponent(workloadId)}/evalSetRuns?workloadType=Flow`, { method: "GET" });
+    return asRecordArray(response, "Eval set runs").map(readRemoteEvalSetRun);
+  }
+  async getEvalSetRun(config, workloadId, evalSetRunId) {
+    const response = await this.requestJson(config, `/unifiedEvals/workloads/${encodeURIComponent(workloadId)}/evalSetRuns/${encodeURIComponent(evalSetRunId)}?workloadType=Flow`, { method: "GET" });
+    if (!isRecord(response)) {
+      throw new Error("Eval set run response must be an object");
+    }
+    return readRemoteEvalSetRun(response);
+  }
+  async getEvalRuns(config, workloadId, evalSetRunId) {
+    const response = await this.requestJson(config, `/unifiedEvals/workloads/${encodeURIComponent(workloadId)}/evalSetRuns/${encodeURIComponent(evalSetRunId)}/evalRuns?workloadType=Flow`, { method: "GET" });
+    return asRecordArray(response, "Eval runs").map(readRemoteEvalRun);
+  }
+  async getSimulatableComponents(config, processKey, processVersion) {
+    const params = new URLSearchParams({ workloadType: "Agents" });
+    if (processVersion) {
+      params.set("processVersion", processVersion);
+    }
+    const data = await this.requestJson(config, `/unifiedEvals/processes/${encodeURIComponent(processKey)}/simulatableComponents?${params.toString()}`, { method: "GET" }, METADATA_FETCH_TIMEOUT_MS);
+    const components = Array.isArray(data.components) ? data.components : [];
+    return components.filter((c) => isRecord(c) && typeof c.id === "string" && typeof c.name === "string" && c.isEnabled === true);
+  }
+  apiBase(config) {
+    return `${config.baseUrl}/${config.organizationId}/${config.tenantName}/agentsruntime_/api`;
+  }
+  headers(config) {
+    return {
+      Authorization: `Bearer ${config.authToken}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "X-UiPath-Internal-TenantId": config.tenantId,
+      "X-UiPath-Internal-AccountId": config.organizationId
+    };
+  }
+  async requestJson(config, path, request, timeoutMs) {
+    let response;
+    let text;
+    try {
+      response = await fetch(`${this.apiBase(config)}${path}`, {
+        method: request.method,
+        headers: {
+          ...this.headers(config),
+          ...request.headers
+        },
+        body: request.body,
+        ...timeoutMs !== undefined ? { signal: AbortSignal.timeout(timeoutMs) } : {}
+      });
+      text = await response.text();
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "TimeoutError") {
+        throw new Error(`Unified eval API request timed out after ${timeoutMs}ms (${request.method} ${path})`);
+      }
+      throw new Error(`Unified eval API request failed (${request.method} ${path}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!response.ok) {
+      const body = text.length > MAX_ERROR_BODY_LENGTH ? `${text.slice(0, MAX_ERROR_BODY_LENGTH)}… (truncated)` : text;
+      throw new Error(`Unified eval API returned ${response.status}: ${body}`);
+    }
+    if (!text) {
+      throw new Error(`Unified eval API returned ${response.status} with empty body`);
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      const preview = text.length > MAX_ERROR_BODY_LENGTH ? `${text.slice(0, MAX_ERROR_BODY_LENGTH)}… (truncated)` : text;
+      throw new Error(`Unified eval API returned ${response.status} with non-JSON body (${request.method} ${path}): ${preview}`);
+    }
+  }
+}
+
+export { FlowEvalRunApi };
+
+//# debugId=5D85BC1B427DCC6164756E2164756E21

package/dist/{packager-tool-am67sn1c.js → packager-tool-xtkgeccn.js}

@@ -1,6 +1,6 @@
 import {
   catchError
-} from "./packager-tool-79gws1zn.js";
+} from "./packager-tool-z6nkdv48.js";
 
 // ../case-tool/src/services/schema-utils.ts
 function getMutatedType(variable) {