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

package/dist/{packager-tool-rew0hp2h.js → packager-tool-6k8s7pt9.js}

@@ -2382,7 +2382,7 @@ var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{1
 var EMAIL_PATTERN = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
 var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
 var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
-var PADDED_BASE64_PATTERN = /[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
+var PADDED_BASE64_PATTERN = /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
 var BASE64_WITH_PLUS_PATTERN = /[A-Za-z0-9+/]{40,}/g;
 var USER_HOME_PATTERN = /(?<![A-Za-z0-9._-])([/\\])(Users|home|Profiles)([/\\])([^/\\]+)/gi;
 var UNC_PATH_PATTERN = /(^|[\s"'<>|=,;([{])(\\\\[^\s"'<>|]+)/g;
@@ -2429,7 +2429,7 @@ var QUOTED_LITERAL_PATTERN = new RegExp([
   `(?<![A-Za-z0-9])"(?:[^\\
 ]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?"(?![A-Za-z0-9])`
 ].join("|"), "g");
-var JSON_BODY_PATTERN = /[{[][^{}[\]]*[:,][^{}[\]]*[\]}]/g;
+var JSON_BODY_PATTERN = /[{[][^{}[\]:,]*[:,][^{}[\]]*[\]}]/g;
 var COLLAPSED_BODY = "{…}";
 var COLLAPSED_BODY_MARKER = "\x01body\x01";
 var MAX_BODY_NESTING = 8;
@@ -2444,10 +2444,13 @@ function collapseJsonBodies(text) {
   }
   return out.split(COLLAPSED_BODY_MARKER).join(COLLAPSED_BODY);
 }
-var TRAILING_PROSE_PUNCT = /[.,;:!?)\]}>'"]+$/;
+var TRAILING_PROSE_PUNCT = `.,;:!?)]}>'"`;
 function peelTrailingPunctuation(match) {
-  const trailing = match.match(TRAILING_PROSE_PUNCT)?.[0] ?? "";
-  return trailing ? [match.slice(0, -trailing.length), trailing] : [match, ""];
+  let end = match.length;
+  while (end > 0 && TRAILING_PROSE_PUNCT.includes(match[end - 1])) {
+    end -= 1;
+  }
+  return [match.slice(0, end), match.slice(end)];
 }
 function redactUrl(raw) {
   try {
@@ -2750,6 +2753,22 @@ function parseHttpStatusFromMessage(message) {
   const status = Number(match[1]);
   return Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
 }
+function findHttpStatusInGraph(error) {
+  for (const node of walkErrorGraph(error)) {
+    const response = node.response;
+    const explicit = typeof node.status === "number" ? node.status : response?.status;
+    if (typeof explicit === "number" && explicit >= 400 && explicit <= 599) {
+      return explicit;
+    }
+    if (typeof node.message === "string") {
+      const parsed = parseHttpStatusFromMessage(node.message);
+      if (parsed !== undefined && parsed >= 400) {
+        return parsed;
+      }
+    }
+  }
+  return;
+}
 function isHtmlDocument(body) {
   return /^\s*(<!doctype html|<html\b)/i.test(body);
 }
@@ -2863,7 +2882,8 @@ async function extractErrorDetails(error, options) {
   }
   let message;
   let result = "Failure";
-  const classification = classifyError(status, error);
+  const classificationStatus = status ?? findHttpStatusInGraph(error);
+  const classification = classifyError(classificationStatus, error);
   let retry = classification.retry;
   if (status === 401) {
     message = DEFAULT_401;
@@ -2939,8 +2959,8 @@ async function extractErrorDetails(error, options) {
     details = describeThrownValue(error);
   }
   const context = {};
-  if (status) {
-    context.httpStatus = status;
+  if (classificationStatus) {
+    context.httpStatus = classificationStatus;
   }
   if (parsedBody?.errorCode && typeof parsedBody.errorCode === "string") {
     context.errorCode = parsedBody.errorCode;
@@ -3520,7 +3540,8 @@ function readRegistryValue(keyPath, valueName) {
   }
   const [error, output] = catchError(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
     encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
   }));
   if (error) {
     return "";
@@ -4235,28 +4256,32 @@ function isPlainRecord(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function extractPagedRows(value) {
+function splitPagedEnvelope(value) {
   if (Array.isArray(value) || !isPlainRecord(value))
     return null;
-  const entries = Object.values(value);
+  const entries = Object.entries(value);
   if (entries.length === 0)
     return null;
-  let rows = null;
-  let hasScalarSibling = false;
-  for (const entry of entries) {
+  let found = null;
+  const meta = Object.create(null);
+  for (const [key, entry] of entries) {
     if (Array.isArray(entry)) {
-      if (rows !== null)
+      if (found !== null)
         return null;
-      rows = entry;
+      found = { key, rows: entry };
     } else if (entry !== null && typeof entry === "object") {
       return null;
     } else {
-      hasScalarSibling = true;
+      meta[key] = entry;
     }
   }
-  if (rows === null || !hasScalarSibling)
+  if (found === null || Object.keys(meta).length === 0)
     return null;
-  return rows;
+  return { ...found, meta };
+}
+function extractPagedRows(value) {
+  const paged = splitPagedEnvelope(value);
+  return paged === null ? null : paged.rows;
 }
 function toLowerCamelCaseKey(key) {
   if (!key)
@@ -4360,6 +4385,9 @@ function printOutput(data, format = "json", logFn, asciiSafe = false, tableRowSt
       }
       break;
     }
+    case "markdown":
+      logFn(renderMarkdown(data));
+      break;
     default: {
       const hasData = "Data" in data && data.Data != null;
       const pagedRows = hasData ? extractPagedRows(data.Data) : null;
@@ -4384,6 +4412,10 @@ function logOutput(data, format = "json", tableRowStyle) {
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `), needsAsciiSafeJson(sink), styleFn);
 }
+var PLUMBING_KEYS = new Set(["code", "log"]);
+function isPlumbingKey(key) {
+  return PLUMBING_KEYS.has(key.toLowerCase());
+}
 function cellToString(val) {
   return val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
 }
@@ -4399,7 +4431,7 @@ function wrapText(text, width) {
 function printTable(data, logFn, externalLogValue, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   const maxWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
   const header = keys.map((key, i) => key.padEnd(maxWidths[i])).join(" | ");
   logFn(header);
@@ -4421,7 +4453,7 @@ function isNonEmptyPlainObject(value) {
 }
 var NESTED_INDENT = "  ";
 function printVerticalTable(data, logFn = console.log, externalLogValue) {
-  const keys = Object.keys(data).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   const isBlockValue = (value) => isPlainObjectArray(value) || isNonEmptyPlainObject(value);
@@ -4452,7 +4484,7 @@ function printVerticalTable(data, logFn = console.log, externalLogValue) {
 function printResizableTable(data, logFn = console.log, externalLogValue, availableWidth, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   if (!process.stdout.isTTY) {
@@ -4526,6 +4558,220 @@ function printResizableTable(data, logFn = console.log, externalLogValue, availa
     logFn(`Log: ${externalLogValue}`);
   }
 }
+var MARKDOWN_MAX_CELL = 200;
+var MARKDOWN_MAX_DEPTH = 3;
+function markdownHeading(depth) {
+  return "#".repeat(Math.min(3 + depth, 6));
+}
+var BACKTICK_RUN = /`+/g;
+function fencedBlock(text) {
+  const first = text.trimStart()[0];
+  const language = first === "<" ? "xml" : first === "{" || first === "[" ? "json" : "";
+  const longestRun = Math.max(0, ...Array.from(text.matchAll(BACKTICK_RUN), (match) => match[0].length));
+  const fence = "`".repeat(Math.max(3, longestRun + 1));
+  return `${fence}${language}
+${text}
+${fence}`;
+}
+function collapseNewlineRuns(text) {
+  return text.split(/(\s+)/).map((part, index) => index % 2 === 1 && part.includes(`
+`) ? " " : part).join("");
+}
+function markdownCell(value) {
+  const text = value instanceof Date ? value.toISOString() : cellToString(value);
+  return collapseNewlineRuns(text).replace(/\|/g, "\\|");
+}
+function markdownLabel(key) {
+  return collapseNewlineRuns(key).replace(/[\\`*|]/g, "\\$&");
+}
+function withoutPlumbing(record) {
+  const kept = Object.create(null);
+  for (const [key, value] of Object.entries(record)) {
+    if (!isPlumbingKey(key))
+      kept[key] = value;
+  }
+  return kept;
+}
+function rowsWithoutPlumbing(rows) {
+  return rows.map((row) => isPlainRecord(row) ? withoutPlumbing(row) : row);
+}
+function markdownTable(rows) {
+  const columns = [];
+  const seen = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  if (columns.length === 0)
+    return null;
+  const cells = rows.map((row) => columns.map((key) => markdownCell(row[key])));
+  if (cells.some((row) => row.some((c) => c.length > MARKDOWN_MAX_CELL))) {
+    return null;
+  }
+  return [
+    `| ${columns.map(markdownLabel).join(" | ")} |`,
+    `| ${columns.map(() => "---").join(" | ")} |`,
+    ...cells.map((row) => `| ${row.join(" | ")} |`)
+  ].join(`
+`);
+}
+function extractMessageSequence(rows) {
+  const messages = [];
+  for (const row of rows) {
+    const message = extractSingleMessage(row);
+    if (message === null)
+      return null;
+    messages.push(message);
+  }
+  return messages.join(`
+
+`);
+}
+function markdownRows(rows, depth) {
+  if (rows.length === 0)
+    return "(none)";
+  if (!isPlainObjectArray(rows)) {
+    return rows.map((item) => `- ${markdownCell(item)}`).join(`
+`);
+  }
+  const prose = extractMessageSequence(rows);
+  if (prose !== null)
+    return prose;
+  const table = markdownTable(rows);
+  if (table !== null)
+    return table;
+  if (depth >= MARKDOWN_MAX_DEPTH) {
+    return fencedBlock(JSON.stringify(rows, null, 2));
+  }
+  return rows.map((row, index) => [
+    `${markdownHeading(depth)} ${index + 1}`,
+    markdownObject(row, depth + 1)
+  ].join(`
+
+`)).join(`
+
+`);
+}
+function markdownObject(obj, depth) {
+  const scalars = [];
+  const blocks = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined)
+      continue;
+    const label = markdownLabel(key);
+    if (Array.isArray(value)) {
+      blocks.push(`${markdownHeading(depth)} ${label}
+
+${markdownRows(value, depth + 1)}`);
+    } else if (isNonEmptyPlainObject(value)) {
+      const nested = depth < MARKDOWN_MAX_DEPTH ? markdownObject(value, depth + 1) : fencedBlock(JSON.stringify(value, null, 2));
+      if (nested !== "") {
+        blocks.push(`${markdownHeading(depth)} ${label}
+
+${nested}`);
+      }
+    } else if (typeof value === "string" && value.includes(`
+`)) {
+      blocks.push(`**${label}:**
+
+${fencedBlock(value)}`);
+    } else {
+      scalars.push(`**${label}:** ${markdownCell(value)}`);
+    }
+  }
+  const sections = scalars.length > 0 ? [scalars.join(`
+`)] : [];
+  sections.push(...blocks);
+  return sections.join(`
+
+`);
+}
+function extractSingleMessage(payload) {
+  if (!isPlainRecord(payload))
+    return null;
+  const keys = Object.keys(payload);
+  if (keys.length !== 1 || keys[0].toLowerCase() !== "message")
+    return null;
+  const value = payload[keys[0]];
+  return typeof value === "string" ? value : null;
+}
+function markdownPayload(payload) {
+  const message = extractSingleMessage(payload);
+  if (message !== null)
+    return message;
+  if (Array.isArray(payload)) {
+    return markdownRows(rowsWithoutPlumbing(payload), 0);
+  }
+  const visible = withoutPlumbing(payload);
+  const paged = splitPagedEnvelope(visible);
+  if (paged !== null) {
+    const meta = markdownObject(paged.meta, 0);
+    const rows = `${markdownHeading(0)} ${markdownLabel(paged.key)}
+
+${markdownRows(rowsWithoutPlumbing(paged.rows), 1)}`;
+    return meta === "" ? rows : `${meta}
+
+${rows}`;
+  }
+  return markdownObject(visible, 0);
+}
+function isPaginationWorthShowing(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const page = value;
+  return page.HasMore === true || typeof page.Offset === "number" && page.Offset > 0;
+}
+function markdownEnvelopeNotes(data) {
+  const envelope = data;
+  const notes = [];
+  const warning = envelope.Warning;
+  if (typeof warning === "string" && warning !== "") {
+    notes.push(`> **Warning:** ${warning}`);
+  }
+  const instructions = envelope.Instructions;
+  if (typeof instructions === "string" && instructions !== "") {
+    notes.push(`> ${instructions}`);
+  }
+  const pagination = envelope.Pagination;
+  if (isPaginationWorthShowing(pagination)) {
+    const body = markdownObject(pagination, 1);
+    if (body !== "") {
+      notes.push(`${markdownHeading(0)} Pagination
+
+${body}`);
+    }
+  }
+  const log = envelope.Log;
+  if (typeof log === "string" && log !== "") {
+    notes.push(`**Log:** ${log}`);
+  }
+  return notes;
+}
+function renderMarkdown(data) {
+  if (data.Result !== RESULTS.Success) {
+    const failure = data;
+    const sections = [`**Failed:** ${failure.Message}`];
+    if (failure.Data != null) {
+      sections.push(markdownPayload(failure.Data));
+    }
+    if (failure.Instructions) {
+      sections.push(`> ${failure.Instructions}`);
+    }
+    return sections.filter((section) => section !== "").join(`
+
+`);
+  }
+  if (!("Data" in data) || data.Data == null) {
+    return markdownObject(withoutPlumbing(data), 0);
+  }
+  return [markdownPayload(data.Data), ...markdownEnvelopeNotes(data)].filter((section) => section !== "").join(`
+
+`);
+}
 function toYaml(data) {
   const codec = getYamlCodec();
   if (!codec) {
@@ -6249,4 +6495,4 @@ function trackShipSucceeded(payload) {
 var factorySlot = singleton("PackagerFactoryProvider");
 export { catchError, extractErrorMessage, extractErrorMessageSync, appendOption, ATTACHMENT_INSTRUCTIONS, ATTACHMENT_UPLOAD_INSTRUCTIONS, parseAttachmentSpec, resolveAttachmentInputs, logger, getOutputFormat, getOutputFormatExplicit, RESULTS, EXIT_CODES, Pagination, OutputFormatter, summarizePlatformBody, InvalidArgumentError, Command, isPreviewBuild, processContext, UIPATH_HOME_DIR, DEFAULT_PAGE_SIZE, hashContent, instructionsFor, isGuid, createHiddenDeprecatedTenantOption, parseLimit, parseOffset, parseBoundedInt, registerPackageMetadataOptions, mapPackageMetadataOptions, msToDuration, PollOutcome, ErrorDecision, MIN_INTERVAL_MS, pollUntil, isTerminalStatus, isFailureStatus, ScreenLogger, getSdkUserAgentToken, addSdkUserAgentHeader, installSdkUserAgentHeader, unsupportedSolutionProjectType, readStdin, splitPackagedName, trackShipSucceeded };
 
-//# debugId=6A784772D19B06A064756E2164756E21
+//# debugId=D645F0A28E70B58464756E2164756E21

package/dist/{packager-tool-29eg86w6.js → packager-tool-6rsegsby.js}

@@ -1,7 +1,5 @@
 import {
-  generateNodeVariables
-} from "./packager-tool-jjpc0yka.js";
-import {
+  CONNECTION_BINDING_RESOURCE,
   MINIMUM_SUPPORTED_SCHEMA_VERSION,
   RESERVED_WORDS,
   VALID_IDENTIFIER_PATTERN,
@@ -10,17 +8,18 @@ import {
   executeWritePlan,
   fileFormatToInMemoryWorkflow,
   generateNextId,
+  generateNodeVariables,
   inMemoryWorkflowToFileFormat,
   planWriteThrough,
   resolveAndConvertWorkflow,
   workflowFileSchema,
   workflowSchema
-} from "./packager-tool-e8td7b01.js";
+} from "./packager-tool-vcjq9xkc.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";
 
-// ../../node_modules/@uipath/flow-core/dist/chunk-PYGLRILU.js
+// ../../node_modules/@uipath/flow-core/dist/chunk-HPJ6Q3LW.js
 function needsBinding(manifest) {
   const model = manifest.model;
   if (!model)
@@ -49,7 +48,7 @@ function createConnectionBinding(connectionId, connectorName) {
   return createBinding({
     name: connectorName,
     value: connectorName,
-    resource: "connection",
+    resource: CONNECTION_BINDING_RESOURCE,
     resourceKey: connectionId,
     propertyAttribute: "connection"
   });
@@ -381,4 +380,4 @@ function summarizeWorkflow(workflow) {
 }
 export { needsBinding, createBinding, createConnectionBinding, createFolderKeyBinding, addBindingIfMissing, createBindingsFromManifest, DEFAULT_LAYOUT_OPTIONS, resolveWidth, resolveHeight, GRID_SPACING, snapToGrid, generateNodeId, generateNodeIdAndName, validateIdentifier, generateEdgeId, createNodeFromManifest, createNode, createEdge, addDefinition, addNode, createWorkflow, addEdge, addBinding, addVariable, readWorkflow, writeWorkflow, writeWorkflowWithRefs, validateWorkflow, summarizeWorkflow };
 
-//# debugId=B91CF0AAF9DF6B2D64756E2164756E21
+//# debugId=81D637C113B74B1B64756E2164756E21

package/dist/packager-tool-795gzq9k.js

@@ -0,0 +1,208 @@
+import {
+  isRecord
+} from "./packager-tool-gzpvdcnw.js";
+
+// 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
+  };
+}
+
+// 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=C7F594BDAF89F66264756E2164756E21