@uipath/maestro-tool 1.204.0 → 1.205.0-preview.258

package/dist/packager-tool-j836z6mq.js

@@ -1,208 +0,0 @@
-import {
-  isRecord
-} from "./packager-tool-64zypey6.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-p7eactax.js

@@ -1,267 +0,0 @@
-import {
-  ensureDirectory
-} from "./packager-tool-7t0xj5pz.js";
-import {
-  logger
-} from "./packager-tool-yv10w46z.js";
-import {
-  buildInlineAgentContract,
-  isInlineAgentNodeType,
-  operateRuntimeOptions,
-  readInlineAgentSource
-} from "./packager-tool-x2py933t.js";
-import {
-  withRuntimeProfile
-} from "./packager-tool-5jb06280.js";
-import {
-  EntryPointType,
-  ProjectType,
-  generateBindingsJson,
-  generateEntryPointsJson,
-  generateOperateJson,
-  getBindingResources,
-  getEntryPoints,
-  isConversationalOrVoiceAgentNodeType,
-  mergeBindingResources
-} from "./packager-tool-qmx87xkf.js";
-import {
-  catchError
-} from "./packager-tool-z1qbc0qf.js";
-
-// ../flow-tool/src/services/packaging-utils.ts
-function fileNodesToPackagingNodes(nodes) {
-  return nodes.map((node) => ({
-    id: node.id,
-    type: node.type,
-    typeVersion: node.typeVersion ?? "1.0",
-    display: node.display,
-    inputs: node.inputs,
-    outputs: node.outputs,
-    ...node.model ? { model: node.model } : {}
-  }));
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function toResourceList(value) {
-  if (!Array.isArray(value))
-    return;
-  const resources = value.filter(isRecord);
-  return resources.length === value.length ? resources : undefined;
-}
-function normalizePackagingBindingsJson(value) {
-  if (!isRecord(value))
-    return;
-  const resources = toResourceList(value.resources);
-  if (!resources)
-    return;
-  return {
-    ...value,
-    version: typeof value.version === "string" ? value.version : "2.0",
-    resources
-  };
-}
-function emptyPackagingBindingsJson() {
-  return { version: "2.0", resources: [] };
-}
-function mergePackagingBindingsJson(bindingsJsons) {
-  const first = bindingsJsons.find((bindingsJson) => bindingsJson !== undefined);
-  return {
-    ...first ?? emptyPackagingBindingsJson(),
-    resources: mergeBindingResources(bindingsJsons.flatMap((bindingsJson) => bindingsJson?.resources ?? []))
-  };
-}
-var inlineAgentPackagerLogger = {
-  debug: (message) => logger.debug(message),
-  info: (message) => logger.info(message),
-  warn: (message) => logger.warn(message),
-  error: (message) => logger.error(message),
-  progress: (message) => logger.info(message),
-  log: (message, level) => {
-    if (level === "Error" /* Error */)
-      logger.error(message);
-    else if (level === "Warning" /* Warn */)
-      logger.warn(message);
-    else if (level === "Debug" /* Debug */)
-      logger.debug(message);
-    else
-      logger.info(message);
-  },
-  logMessage: (message) => inlineAgentPackagerLogger.log(message.message, message.logLevel)
-};
-async function createInlineAgentContract(fs, agentDir) {
-  const outputPath = fs.path.join(fs.env.tmpdir(), `.inline-agent-contract-${crypto.randomUUID()}`);
-  await fs.mkdir(outputPath);
-  try {
-    const built = await buildInlineAgentContract({
-      fileSystem: fs,
-      logger: inlineAgentPackagerLogger,
-      projectPath: agentDir,
-      outputPath
-    });
-    const bindingsJson = normalizePackagingBindingsJson(built.bindingsJson);
-    if (!bindingsJson) {
-      throw new Error("Agent packager returned an invalid binding contract");
-    }
-    return { agentJson: built.agentJson, bindingsJson };
-  } finally {
-    const [cleanupError] = await catchError(fs.rm(outputPath, { recursive: true }));
-    if (cleanupError) {
-      logger.debug(`Could not remove inline-agent contract directory ${outputPath}: ${cleanupError.message}`);
-    }
-  }
-}
-async function inlineAgentExists(fs, projectDir, source) {
-  const agentJsonPath = fs.path.join(projectDir, source, "agent.json");
-  return fs.exists(agentJsonPath);
-}
-async function packageInlineAgents(fs, projectDir, nodes) {
-  const result = [];
-  for (const node of nodes) {
-    if (!isInlineAgentNodeType(node.type))
-      continue;
-    const source = readInlineAgentSource(node);
-    if (!source)
-      continue;
-    if (/[/\\.]/.test(source))
-      continue;
-    if (!await inlineAgentExists(fs, projectDir, source))
-      continue;
-    const contract = await createInlineAgentContract(fs, fs.path.join(projectDir, source));
-    const inputSchema = contract.agentJson.inputSchema ?? {
-      type: "object",
-      properties: {}
-    };
-    const outputSchema = contract.agentJson.outputSchema ?? {
-      type: "object",
-      properties: {}
-    };
-    result.push({
-      source,
-      entryPoint: {
-        filePath: `content/${source}/agent.json`,
-        uniqueId: contract.agentJson.projectId ?? source,
-        type: EntryPointType.Agent,
-        input: inputSchema,
-        output: outputSchema,
-        displayName: contract.agentJson.name ?? "Agent"
-      },
-      agentJson: contract.agentJson,
-      bindingsJson: contract.bindingsJson
-    });
-    logger.info(`Packaged inline agent "${source}" for entry-points`);
-  }
-  return result;
-}
-async function stageInlineAgentPackageFiles(fs, sourceProjectPath, stagingProjectDir, inlineAgents, formatLogMessage) {
-  for (const agent of inlineAgents) {
-    const srcDir = fs.path.join(sourceProjectPath, agent.source);
-    const destDir = fs.path.join(stagingProjectDir, agent.source);
-    if (fs.path.resolve(srcDir) !== fs.path.resolve(destDir) && await fs.exists(srcDir)) {
-      await fs.copyDirectory(srcDir, destDir);
-    }
-    const agentBuilderDir = fs.path.join(destDir, ".agent-builder");
-    await ensureDirectory(fs, agentBuilderDir);
-    await fs.writeFile(fs.path.join(agentBuilderDir, "agent.json"), JSON.stringify({
-      ...agent.agentJson,
-      resources: agent.agentJson.resources ?? [],
-      features: agent.agentJson.features ?? []
-    }, null, 2));
-    await fs.writeFile(fs.path.join(agentBuilderDir, "bindings.json"), `${JSON.stringify(agent.bindingsJson ?? emptyPackagingBindingsJson(), null, 2)}
-`);
-    logger.info(formatLogMessage(agent.source));
-  }
-}
-function buildInlineAgentDescriptors(nodes) {
-  const out = [];
-  for (const node of nodes) {
-    if (!isInlineAgentNodeType(node.type))
-      continue;
-    const source = readInlineAgentSource(node);
-    if (!source)
-      continue;
-    const label = node.display?.label ?? "Agent";
-    out.push({
-      name: label,
-      agentProjectId: source,
-      isConversational: isConversationalOrVoiceAgentNodeType(node.type),
-      entryPointPath: `${source}/agent.json`
-    });
-  }
-  return out;
-}
-async function writePackagingArtifacts(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
-  const { entryPoints } = await writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions, options);
-  return entryPoints;
-}
-async function writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
-  const flowEntryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, definitions, ProjectType.Flow);
-  const entryPoints = [
-    ...flowEntryPoints,
-    ...options.additionalEntryPoints ?? []
-  ];
-  await fs.writeFile(fs.path.join(projectDir, "entry-points.json"), `${JSON.stringify(generateEntryPointsJson(entryPoints), null, 2)}
-`);
-  const bindingResources = getBindingResources(packagingNodes, bindings, definitions);
-  const bindingsJson = normalizePackagingBindingsJson(generateBindingsJson(bindingResources)) ?? emptyPackagingBindingsJson();
-  const stagedBindingsJson = mergePackagingBindingsJson([
-    bindingsJson,
-    ...options.additionalBindingsJsons ?? []
-  ]);
-  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(stagedBindingsJson, null, 2)}
-`);
-  const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
-  const operateJson = withRuntimeProfile(generateOperateJson(projectId, mainEntryPoint, operateRuntimeOptions(packagingNodes)), options.profile ?? "Standard" /* Standard */);
-  await fs.writeFile(fs.path.join(projectDir, "operate.json"), `${JSON.stringify(operateJson, null, 2)}
-`);
-  const packageDescriptorJson = options.packageDescriptorJson ?? {
-    $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-    files: {
-      "operate.json": "operate.json",
-      "entry-points.json": "entry-points.json",
-      "bindings.json": "bindings_v2.json",
-      [bpmnFileName]: bpmnFileName,
-      ...flowFileName ? { [flowFileName]: flowFileName } : {}
-    }
-  };
-  await fs.writeFile(fs.path.join(projectDir, "package-descriptor.json"), `${JSON.stringify(packageDescriptorJson, null, 2)}
-`);
-  return { entryPoints, bindingsJson: stagedBindingsJson };
-}
-function backfillNodeModelsFromDefinitions(nodes, definitions) {
-  if (definitions.length === 0)
-    return nodes;
-  const definitionByType = new Map;
-  for (const def of definitions) {
-    if (def?.nodeType)
-      definitionByType.set(def.nodeType, def);
-  }
-  return nodes.map((n) => {
-    if (n.model)
-      return n;
-    const def = definitionByType.get(n.type);
-    if (!def?.model)
-      return n;
-    return { ...n, model: def.model };
-  });
-}
-async function regenerateBindingsFile(fs, flowFilePath) {
-  const absolutePath = fs.path.resolve(flowFilePath);
-  const projectDir = fs.path.dirname(absolutePath);
-  const content = await fs.readFile(absolutePath, "utf-8");
-  if (!content) {
-    throw new Error(`Could not read .flow file at ${absolutePath}`);
-  }
-  const [parseErr, flowData] = catchError(() => JSON.parse(content));
-  if (parseErr) {
-    throw new Error(`Failed to parse .flow file at ${absolutePath}: ${parseErr.message}`);
-  }
-  const packagingNodes = backfillNodeModelsFromDefinitions(fileNodesToPackagingNodes(flowData.nodes ?? []), flowData.definitions ?? []);
-  const bindingResources = getBindingResources(packagingNodes, flowData.bindings ?? [], flowData.definitions ?? []);
-  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}
-`);
-}
-
-export { fileNodesToPackagingNodes, packageInlineAgents, stageInlineAgentPackageFiles, buildInlineAgentDescriptors, writePackagingArtifacts, writePackagingArtifactsDetailed, regenerateBindingsFile };
-
-//# debugId=1A42D1D632F238BA64756E2164756E21

package/dist/packager-tool-xjtv580j.js

@@ -1,13 +0,0 @@
-// ../case-tool/src/services/connector-task-types.ts
-var CONNECTOR_TASK_TYPES = new Set([
-  "execute-connector-activity",
-  "wait-for-connector"
-]);
-var SERVICE_TYPE_BY_TASK = {
-  "execute-connector-activity": "Intsvc.ActivityExecution",
-  "wait-for-connector": "Intsvc.WaitForEvent"
-};
-
-export { CONNECTOR_TASK_TYPES, SERVICE_TYPE_BY_TASK };
-
-//# debugId=855CDC331781E19064756E2164756E21