@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/flow-eval-run-service-01kdky72.js

@@ -0,0 +1,961 @@
+import {
+  FlowEvalPathResolver,
+  findEvalSet,
+  getLinkedEvaluators,
+  readStartNodeId,
+  readWorkflowId
+} from "./packager-tool-r0xpcqwg.js";
+import {
+  readNodeTargetId
+} from "./packager-tool-g0eha8ge.js";
+import {
+  writeResolvedFlow
+} from "./packager-tool-raq2wbwp.js";
+import {
+  package_default
+} from "./packager-tool-7b6tpg7y.js";
+import {
+  isRecord,
+  isUUID
+} from "./packager-tool-8j92afwp.js";
+import {
+  ensureProcessBindings
+} from "./packager-tool-v2rkcehq.js";
+import {
+  fileNodesToPackagingNodes,
+  packageInlineAgents,
+  stageInlineAgentPackageFiles,
+  writePackagingArtifactsDetailed
+} from "./packager-tool-v86fdwvs.js";
+import {
+  FlowEvalFileStore,
+  ensureDirectory
+} from "./packager-tool-jc34wvrw.js";
+import"./packager-tool-4hx14snw.js";
+import"./packager-tool-a1hbfmws.js";
+import"./packager-tool-cdwpc9fh.js";
+import"./packager-tool-g9y14b10.js";
+import"./packager-tool-5z1eg3ea.js";
+import {
+  extractStartEventId,
+  getPersonalFolderInfo,
+  getPersonalFolderKey,
+  patchConnectionOverwrites,
+  prepareForCustomDebug
+} from "./packager-tool-v9rrz038.js";
+import"./packager-tool-fjaa8d3v.js";
+import"./packager-tool-v9psxdy5.js";
+import"./packager-tool-ywqc9rtf.js";
+import"./packager-tool-f0kd5kq4.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-7exrv6w7.js";
+import {
+  buildSolutionPackageFromDir,
+  getStudioWebSolutionProjects,
+  uploadOrOverwriteSolution
+} from "./packager-tool-8dszjcg5.js";
+import {
+  findSolutionFile,
+  readUipxFile,
+  updateSolutionFile
+} from "./packager-tool-eebq62fq.js";
+import {
+  readFlowWorkflow,
+  resolveProjectFlowFile,
+  writeFlowWorkflow
+} from "./packager-tool-94w17vf8.js";
+import {
+  convertFlowToBpmn,
+  replaceExporterVersion,
+  setPublishIntentOnInlineAgents
+} from "./packager-tool-6m078z5s.js";
+import"./packager-tool-tn5e7wnb.js";
+import"./packager-tool-xhzfwa5p.js";
+import"./packager-tool-nkrmjr3a.js";
+import"./packager-tool-rs6jm14d.js";
+import"./packager-tool-hk1gxnth.js";
+import"./packager-tool-em5r6g6j.js";
+import"./packager-tool-9bec251q.js";
+import"./packager-tool-z9bfhmm5.js";
+import"./packager-tool-6ejqwbw9.js";
+import"./packager-tool-mcaf4ewf.js";
+import"./packager-tool-eypvc2kv.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-5qaxht3k.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-p9stswjj.js";
+import"./packager-tool-vpqyvh4c.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-58q3tvh7.js";
+import"./packager-tool-sc961w0q.js";
+import {
+  inMemoryWorkflowToFileFormat,
+  isVoiceAgentNodeType
+} from "./packager-tool-m5qfverj.js";
+import"./packager-tool-e0p2zsyc.js";
+import"./packager-tool-a42jnpy5.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-1yh8g550.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
+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);
+  }
+  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) {
+    const response = await fetch(`${this.apiBase(config)}${path}`, {
+      method: request.method,
+      headers: {
+        ...this.headers(config),
+        ...request.headers
+      },
+      body: request.body
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`Unified eval API returned ${response.status}: ${text}`);
+    }
+    if (!text) {
+      throw new Error(`Unified eval API returned ${response.status} with empty body`);
+    }
+    return JSON.parse(text);
+  }
+}
+
+// src/services/flow-local-workspace-eval-preparer.ts
+function toForwardSlash(path) {
+  return path.replace(/\\/g, "/");
+}
+
+class FlowLocalWorkspaceEvalPreparer {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  async prepare(projectPath, config, existingSolutionIdOverride, options = {}) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const projectFilePath = this.fs.path.join(absoluteProjectPath, "project.uiproj");
+    if (!await this.fs.exists(projectFilePath)) {
+      throw new Error(`Not a valid flow project directory: missing project.uiproj in ${absoluteProjectPath}`);
+    }
+    const projectFileContent = await this.fs.readFile(projectFilePath, "utf-8");
+    if (projectFileContent === null) {
+      throw new Error(`Failed to read project.uiproj in ${absoluteProjectPath}`);
+    }
+    const projectFile = JSON.parse(String(projectFileContent));
+    if (!projectFile.Name) {
+      throw new Error(`Invalid project.uiproj in ${absoluteProjectPath}: missing Name`);
+    }
+    const projectName = projectFile.Name;
+    const safeProjectName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const flowFilePath = await resolveProjectFlowFile(absoluteProjectPath);
+    const flowFileName = this.fs.path.basename(flowFilePath);
+    const flowBaseName = flowFileName.replace(/\.flow$/i, "");
+    const bpmnFileName = `${flowBaseName}.bpmn`;
+    const { workflow } = await readFlowWorkflow(flowFilePath);
+    ensureProcessBindings(workflow);
+    logger.info("Found .flow file, converting to BPMN for eval debug...");
+    const bpmnXml = await this.convertToBpmn(workflow);
+    const solutionDir = this.fs.path.resolve(absoluteProjectPath, "..");
+    const stagingDir = this.fs.path.join(this.fs.env.tmpdir(), `.flow-eval-staging-${safeProjectName}-${Date.now()}`);
+    await this.fs.mkdir(stagingDir);
+    let uisPath;
+    try {
+      const [uipxError, uipxResult] = await catchError(readUipxFile(this.fs, solutionDir));
+      if (uipxError) {
+        logger.warn(`Could not read .uipx: ${uipxError.message}. Falling back to flow-only upload.`);
+      }
+      const flowProjectRelDir = this.resolveProjectRelativeDir(solutionDir, absoluteProjectPath, uipxResult?.uipx.Projects ?? []);
+      if (uipxResult) {
+        await this.fs.writeFile(this.fs.path.join(stagingDir, uipxResult.uipxFileName), JSON.stringify(uipxResult.uipx, null, 4));
+      } else {
+        await this.writeSingleProjectSolutionMetadata(stagingDir, safeProjectName, flowProjectRelDir);
+      }
+      await this.copySolutionResources(solutionDir, stagingDir);
+      await this.copySiblingProjects(solutionDir, stagingDir, flowProjectRelDir, uipxResult?.uipx.Projects ?? []);
+      const stagingProjectDir = this.fs.path.join(stagingDir, flowProjectRelDir);
+      await ensureDirectory(this.fs, stagingProjectDir);
+      await this.writeFlowProjectArtifacts(stagingProjectDir, projectFileContent, workflow, flowFileName, bpmnFileName, bpmnXml, flowBaseName, absoluteProjectPath);
+      logger.info("Building solution package for eval debug...");
+      uisPath = await buildSolutionPackageFromDir(this.fs, stagingDir);
+      const solutionInfo = await findSolutionFile(this.fs, absoluteProjectPath);
+      const apiConfig = this.createApiConfig(config);
+      const folder = await getPersonalFolderInfo(apiConfig);
+      const importResult = await uploadOrOverwriteSolution(apiConfig, config.organizationName, uisPath, existingSolutionIdOverride ?? solutionInfo?.solutionId, this.fs);
+      if (options.persistLocalMetadata ?? true) {
+        await updateSolutionFile(this.fs, absoluteProjectPath, importResult.id);
+        await this.updateLocalWorkspaceMarker(solutionDir, importResult.id);
+      }
+      const patchedCount = await patchConnectionOverwrites(apiConfig, config.organizationName, importResult.id, solutionDir, folder, this.fs);
+      if (patchedCount > 0) {
+        logger.info(`Patched ${patchedCount} connection overwrite(s) on Studio Web`);
+      }
+      const matchedProject = this.resolveImportedProject(importResult, projectName);
+      return {
+        solutionId: importResult.id,
+        studioWebProjectId: matchedProject.id,
+        folderKey: folder.key,
+        projects: importResult.projects
+      };
+    } finally {
+      const [cleanupErr] = await catchError((async () => {
+        if (uisPath) {
+          await this.fs.rm(uisPath);
+        }
+        await this.fs.rm(stagingDir, { recursive: true });
+      })());
+      if (cleanupErr) {
+        logger.warn(`Cleanup failed: ${cleanupErr.message}`);
+      }
+    }
+  }
+  async convertToBpmn(workflow) {
+    const hasVoiceAgent = (workflow.nodes ?? []).some((node) => isVoiceAgentNodeType(node.type));
+    if (hasVoiceAgent) {
+      throw new Error("Evaluation runs are not supported for flows with voice agent nodes.");
+    }
+    const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+    setPublishIntentOnInlineAgents(fileFormat);
+    const { bpmn } = await convertFlowToBpmn(JSON.stringify(fileFormat, null, 2));
+    return replaceExporterVersion(bpmn, package_default.version);
+  }
+  resolveProjectRelativeDir(solutionDir, projectPath, projects) {
+    const projectRelativePath = toForwardSlash(this.fs.path.relative(solutionDir, this.fs.path.join(projectPath, "project.uiproj")));
+    const matchedProject = projects.find((project) => toForwardSlash(project.ProjectRelativePath) === projectRelativePath);
+    return toForwardSlash(this.fs.path.dirname(matchedProject?.ProjectRelativePath ?? projectRelativePath));
+  }
+  async writeSingleProjectSolutionMetadata(stagingDir, projectName, projectRelativeDir) {
+    const solutionId = crypto.randomUUID();
+    const projectId = crypto.randomUUID();
+    const projectRelativePath = `${projectRelativeDir}/project.uiproj`;
+    await this.fs.writeFile(this.fs.path.join(stagingDir, "SolutionStorage.json"), JSON.stringify({
+      SolutionId: solutionId,
+      Projects: [
+        {
+          ProjectId: projectId,
+          ProjectRelativePath: projectRelativePath
+        }
+      ]
+    }, null, 4));
+    await this.fs.writeFile(this.fs.path.join(stagingDir, `${projectName}Solution.uipx`), JSON.stringify({
+      SolutionId: solutionId,
+      Projects: [
+        {
+          Type: "Flow",
+          ProjectRelativePath: projectRelativePath,
+          Id: projectId
+        }
+      ]
+    }, null, 4));
+  }
+  async copySolutionResources(solutionDir, stagingDir) {
+    const resourcesDir = this.fs.path.join(solutionDir, "resources");
+    if (await this.fs.exists(resourcesDir)) {
+      await this.fs.copyDirectory(resourcesDir, this.fs.path.join(stagingDir, "resources"));
+    }
+  }
+  async copySiblingProjects(solutionDir, stagingDir, flowProjectRelDir, projects) {
+    for (const project of projects) {
+      const projectDir = toForwardSlash(this.fs.path.dirname(project.ProjectRelativePath));
+      if (projectDir === flowProjectRelDir) {
+        continue;
+      }
+      const srcProjectPath = this.fs.path.join(solutionDir, projectDir);
+      if (await this.fs.exists(srcProjectPath)) {
+        await this.fs.copyDirectory(srcProjectPath, this.fs.path.join(stagingDir, projectDir));
+        logger.info(`Included project "${projectDir}" (${project.Type}) in eval debug solution package`);
+      } else {
+        logger.warn(`Project directory not found: ${srcProjectPath} - skipping`);
+      }
+    }
+  }
+  async writeFlowProjectArtifacts(stagingProjectDir, projectFileContent, flowData, flowFileName, bpmnFileName, bpmnXml, flowBaseName, sourceProjectPath) {
+    await this.fs.writeFile(this.fs.path.join(stagingProjectDir, "project.uiproj"), projectFileContent);
+    await writeFlowWorkflow(this.fs.path.join(stagingProjectDir, flowFileName), flowData);
+    await this.fs.writeFile(this.fs.path.join(stagingProjectDir, bpmnFileName), bpmnXml);
+    const startEventId = extractStartEventId(bpmnXml);
+    const packagingNodes = fileNodesToPackagingNodes(flowData.nodes);
+    const bindings = flowData.bindings ?? [];
+    const workflowVariables = flowData.variables ?? {};
+    const definitions = flowData.definitions ?? [];
+    const inlineAgentPackages = await packageInlineAgents(this.fs, sourceProjectPath, flowData.nodes);
+    await writePackagingArtifactsDetailed(this.fs, stagingProjectDir, flowData.id, packagingNodes, bindings, workflowVariables, bpmnFileName, startEventId, flowFileName, definitions, {
+      additionalEntryPoints: inlineAgentPackages.map((agent) => agent.entryPoint),
+      additionalBindingsJsons: inlineAgentPackages.map((agent) => agent.bindingsJson)
+    });
+    await writeResolvedFlow(this.fs, stagingProjectDir, flowBaseName, flowData);
+    await stageInlineAgentPackageFiles(this.fs, sourceProjectPath, stagingProjectDir, inlineAgentPackages, (source) => `Staged inline agent "${source}" for eval debug`);
+  }
+  createApiConfig(config) {
+    return {
+      baseUrl: config.baseUrl,
+      organizationId: config.organizationId,
+      tenantName: config.tenantName,
+      tenantId: config.tenantId,
+      authToken: config.authToken,
+      organizationUnitId: config.organizationUnitId
+    };
+  }
+  resolveImportedProject(importResult, projectName) {
+    const exactProject = importResult.projects.find((project) => project.name === projectName);
+    if (exactProject?.id) {
+      return exactProject;
+    }
+    const [onlyProject] = importResult.projects;
+    if (importResult.projects.length === 1 && onlyProject?.id) {
+      return onlyProject;
+    }
+    throw new Error(`Upload response had ${importResult.projects.length} projects and none matched "${projectName}"; refusing to guess.`);
+  }
+  async updateLocalWorkspaceMarker(solutionDir, solutionId) {
+    const markerPath = this.fs.path.join(solutionDir, ".sw-path-marker");
+    if (await this.fs.exists(markerPath)) {
+      await this.fs.writeFile(markerPath, solutionId);
+    }
+  }
+}
+
+// src/services/flow-eval-run-context.ts
+var VSIX_LOCAL_SOLUTION_PREFIX = "uip-sw-local://Folder/";
+var AGENT_TARGET_RUNTIME = "pythonAgent";
+var INLINE_AGENT_PROJECT_TYPE = "Agent";
+var INLINE_AGENT_DEBUG_EXECUTOR_COMMAND = "debug";
+var INLINE_AGENT_DEBUG_ATTACH_NONE_ARG = "--attach=none";
+function toForwardSlash2(path) {
+  return path.replace(/\\/g, "/");
+}
+function projectDirFromRelativePath(fs, relativePath) {
+  return toForwardSlash2(fs.path.dirname(relativePath ?? ""));
+}
+function projectMatchesDir(fs, projectRelativePath, projectRelDir, absoluteProjectPath) {
+  const projectDir = projectDirFromRelativePath(fs, projectRelativePath);
+  return projectDir === projectRelDir || fs.path.basename(projectDir) === fs.path.basename(absoluteProjectPath);
+}
+function readRecordValue(record, key) {
+  return record?.[key];
+}
+function firstString(values) {
+  return values.find((value) => typeof value === "string" && value !== "");
+}
+function readFlowStringProperty(flowContent, property) {
+  const [parseError, parsed] = catchError(() => JSON.parse(flowContent));
+  if (parseError || !isRecord(parsed)) {
+    return;
+  }
+  const value = parsed[property];
+  return typeof value === "string" && value !== "" ? value : undefined;
+}
+function readFlowProjectId(flowContent) {
+  const projectId = readFlowStringProperty(flowContent, "projectId");
+  return projectId && isUUID(projectId) ? projectId : undefined;
+}
+function readVsixLocalSolutionId(flowContent) {
+  const solutionId = readFlowStringProperty(flowContent, "solutionId");
+  if (!solutionId?.startsWith(VSIX_LOCAL_SOLUTION_PREFIX)) {
+    return;
+  }
+  const localSolutionId = solutionId.slice(VSIX_LOCAL_SOLUTION_PREFIX.length);
+  return isUUID(localSolutionId) ? localSolutionId : undefined;
+}
+function isConversationalAgentNodeType(nodeType) {
+  return nodeType === "uipath.agent.conversational" || nodeType.startsWith("uipath.agent.conversational.");
+}
+function getInlineAgentDebugExecutorEntryPoint(project) {
+  const entryPointPath = project.entryPointPath?.replace(/^\/+/, "");
+  if (!entryPointPath) {
+    return "agent.json";
+  }
+  const safeProjectPath = project.id.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const prefixes = [
+    `content/${project.id}/`,
+    `${project.id}/`,
+    `content/${safeProjectPath}/`,
+    `${safeProjectPath}/`
+  ];
+  for (const prefix of prefixes) {
+    if (entryPointPath.startsWith(prefix)) {
+      return entryPointPath.slice(prefix.length) || "agent.json";
+    }
+  }
+  return entryPointPath;
+}
+function withInlineAgentExecutorInfo(project) {
+  if (project.type.toLowerCase() !== INLINE_AGENT_PROJECT_TYPE.toLowerCase() || !project.entryPointPath) {
+    return project;
+  }
+  return {
+    ...project,
+    executorInfo: JSON.stringify({
+      projectId: project.id,
+      command: INLINE_AGENT_DEBUG_EXECUTOR_COMMAND,
+      entryPoint: getInlineAgentDebugExecutorEntryPoint(project),
+      args: [INLINE_AGENT_DEBUG_ATTACH_NONE_ARG]
+    })
+  };
+}
+function extractInlineAgentProjects(flowContent, currentProjectId) {
+  const parsed = JSON.parse(flowContent);
+  if (!isRecord(parsed) || !Array.isArray(parsed.nodes)) {
+    return [];
+  }
+  const seen = new Set;
+  return parsed.nodes.filter(isRecord).flatMap((node) => {
+    const nodeType = typeof node.type === "string" ? node.type : "";
+    const model = isRecord(node.model) ? node.model : undefined;
+    const inputs = isRecord(node.inputs) ? node.inputs : undefined;
+    const display = isRecord(node.display) ? node.display : undefined;
+    const serviceType = typeof model?.serviceType === "string" ? model.serviceType.toLowerCase() : "";
+    const lowerType = nodeType.toLowerCase();
+    const isAgent = lowerType.startsWith("uipath.agent") || serviceType.includes("agent");
+    if (!isAgent) {
+      return [];
+    }
+    const agentProjectId = firstString([
+      readRecordValue(inputs, "source"),
+      readRecordValue(model, "source"),
+      readRecordValue(inputs, "agentProjectId"),
+      readRecordValue(model, "agentProjectId")
+    ]);
+    if (!agentProjectId || agentProjectId === currentProjectId || seen.has(agentProjectId)) {
+      return [];
+    }
+    seen.add(agentProjectId);
+    return [
+      withInlineAgentExecutorInfo({
+        id: agentProjectId,
+        name: typeof display?.label === "string" ? display.label : "Agent",
+        type: "Agent",
+        entryPointPath: `${agentProjectId}/agent.json`,
+        targetRuntime: AGENT_TARGET_RUNTIME,
+        targetFramework: "Portable",
+        isConversational: isConversationalAgentNodeType(nodeType),
+        requiresUserInteraction: false
+      })
+    ];
+  });
+}
+
+class FlowEvalRunContextResolver {
+  fs;
+  pathResolver;
+  localWorkspacePreparer;
+  constructor(fs, pathResolver, localWorkspacePreparer = new FlowLocalWorkspaceEvalPreparer(fs)) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+    this.localWorkspacePreparer = localWorkspacePreparer;
+  }
+  async resolveTarget(projectPath, evalSet, options, requireSolutionId, config) {
+    const absoluteProjectPath = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const solutionDir = this.fs.path.dirname(absoluteProjectPath);
+    const projectRelDir = toForwardSlash2(this.fs.path.relative(solutionDir, absoluteProjectPath));
+    const [uipxError, uipxResult] = await catchError(readUipxFile(this.fs, solutionDir));
+    const solutionStorage = await this.readSolutionStorage(solutionDir);
+    const localWorkspaceMarker = await this.readLocalWorkspaceMarker(solutionDir);
+    const uipxProject = uipxResult?.uipx.Projects.find((project) => projectMatchesDir(this.fs, project.ProjectRelativePath, projectRelDir, absoluteProjectPath));
+    const storageProject = solutionStorage?.Projects?.find((project) => projectMatchesDir(this.fs, project.ProjectRelativePath, projectRelDir, absoluteProjectPath));
+    const flowFilePath = await this.pathResolver.findFlowFile(absoluteProjectPath);
+    const flowContent = String(await this.fs.readFile(flowFilePath, "utf-8"));
+    const vsixLocalSolutionId = readVsixLocalSolutionId(flowContent);
+    const isVsixLocalProject = localWorkspaceMarker === undefined && vsixLocalSolutionId !== undefined;
+    const flowProjectId = readFlowProjectId(flowContent);
+    if (uipxError && !solutionStorage && !options.projectId && !isVsixLocalProject) {
+      throw new Error("Could not resolve Flow project metadata from a parent .uipx or SolutionStorage.json file. Use a flow project extracted with 'uip solution download --extract', or provide --project-id.");
+    }
+    const localProjectDebugId = await this.readLocalProjectId(absoluteProjectPath);
+    let studioWebProjectId = options.projectId ?? (localWorkspaceMarker ? storageProject?.CloudProjectId ?? storageProject?.ProjectId ?? uipxProject?.Id ?? localProjectDebugId : isVsixLocalProject ? flowProjectId ?? localProjectDebugId ?? storageProject?.CloudProjectId ?? storageProject?.ProjectId ?? uipxProject?.Id : localProjectDebugId ?? storageProject?.CloudProjectId ?? storageProject?.ProjectId ?? uipxProject?.Id);
+    const projectIdFromUipxManifest = options.projectId === undefined && localWorkspaceMarker === undefined && !isVsixLocalProject && localProjectDebugId === undefined && storageProject?.CloudProjectId === undefined && storageProject?.ProjectId === undefined && uipxProject?.Id !== undefined;
+    const isLocalWorkspace = localWorkspaceMarker !== undefined;
+    const solutionId = options.solutionId ?? (isLocalWorkspace ? localWorkspaceMarker.SolutionId ?? solutionStorage?.SolutionId ?? uipxResult?.uipx.SolutionId : isVsixLocalProject ? vsixLocalSolutionId ?? solutionStorage?.SolutionId ?? uipxResult?.uipx.SolutionId : solutionStorage?.SolutionId ?? uipxResult?.uipx.SolutionId);
+    if (!studioWebProjectId) {
+      throw new Error("Could not resolve Flow project ID. Provide --project-id or run from a project listed in the parent .uipx or SolutionStorage.json file.");
+    }
+    let cloudProjects;
+    if (projectIdFromUipxManifest && config && solutionId) {
+      cloudProjects = await this.fetchCloudProjects(config, solutionId);
+      studioWebProjectId = this.mapDesignIdToCloudProjectId(cloudProjects, studioWebProjectId, this.fs.path.basename(absoluteProjectPath), solutionId);
+    }
+    const workloadId = readWorkflowId(flowContent) ?? studioWebProjectId;
+    if (requireSolutionId && !solutionId) {
+      throw new Error("Could not resolve solution ID. Provide --solution-id or run from a project whose parent directory contains a .uipx or SolutionStorage.json file.");
+    }
+    const additionalProjects = await this.resolveAdditionalProjects(studioWebProjectId, flowContent, uipxResult?.uipx.Projects ?? [], solutionStorage, uipxProject?.Id, cloudProjects);
+    return {
+      projectPath: absoluteProjectPath,
+      evalSet,
+      workloadId,
+      studioWebProjectId,
+      solutionId,
+      solutionName: this.resolveSolutionName(solutionDir, uipxResult),
+      ...isLocalWorkspace ? { isLocalWorkspace } : {},
+      ...isVsixLocalProject ? { isVsixLocalProject } : {},
+      ...additionalProjects.length > 0 ? { additionalProjects } : {}
+    };
+  }
+  async buildExecutionContext(target, config, options) {
+    if (!target.solutionId) {
+      throw new Error("Could not resolve solution ID.");
+    }
+    const shouldPrepareLocalProject = (target.isLocalWorkspace || target.isVsixLocalProject) && !options.projectId && !options.solutionId;
+    const resolvedIds = shouldPrepareLocalProject ? await this.resolvePreparedDebugIds(target, config, options.folderKey) : {
+      studioWebProjectId: target.studioWebProjectId,
+      solutionId: target.solutionId,
+      folderKey: options.folderKey ?? (await getPersonalFolderKey({
+        baseUrl: config.baseUrl,
+        organizationId: config.organizationId,
+        tenantName: config.tenantName,
+        tenantId: config.tenantId,
+        authToken: config.authToken,
+        organizationUnitId: config.organizationUnitId
+      })).key
+    };
+    const additionalProjects = resolvedIds.additionalProjects ?? target.additionalProjects;
+    return {
+      workloadId: target.workloadId,
+      studioWebProjectId: resolvedIds.studioWebProjectId,
+      solutionId: resolvedIds.solutionId,
+      folderKey: resolvedIds.folderKey,
+      entrypoint: await this.resolveEntrypoint(target.projectPath, target.evalSet, options.entryPoint),
+      ...additionalProjects ? { additionalProjects } : {},
+      debugMode: options.debugMode ?? (readNodeTargetId(target.evalSet) !== undefined ? 3 : 1)
+    };
+  }
+  async resolvePreparedDebugIds(target, config, folderKeyOverride) {
+    const preparedProject = target.isVsixLocalProject ? await this.localWorkspacePreparer.prepare(target.projectPath, config, target.solutionId, { persistLocalMetadata: false }) : await this.localWorkspacePreparer.prepare(target.projectPath, config, target.solutionId);
+    const folderKey = folderKeyOverride ?? preparedProject.folderKey;
+    if (target.isVsixLocalProject) {
+      return {
+        studioWebProjectId: preparedProject.studioWebProjectId,
+        solutionId: preparedProject.solutionId,
+        folderKey,
+        ...target.additionalProjects ? {
+          additionalProjects: this.remapUploadedAdditionalProjects(target.additionalProjects, preparedProject.projects, preparedProject.studioWebProjectId)
+        } : {}
+      };
+    }
+    const debugIds = await prepareForCustomDebug({
+      config,
+      solutionId: preparedProject.solutionId,
+      projectId: preparedProject.studioWebProjectId,
+      solutionName: target.solutionName ?? "Solution",
+      folderKey
+    });
+    return {
+      studioWebProjectId: debugIds.projectDebugId,
+      solutionId: debugIds.solutionDebugId,
+      folderKey,
+      ...target.additionalProjects ? {
+        additionalProjects: this.remapUploadedAdditionalProjects(target.additionalProjects, preparedProject.projects, preparedProject.studioWebProjectId)
+      } : {}
+    };
+  }
+  remapUploadedAdditionalProjects(additionalProjects, uploadedProjects, currentProjectId) {
+    return additionalProjects.map((project) => {
+      if (project.entryPointPath) {
+        return project;
+      }
+      const uploadedProject = uploadedProjects.find((candidate) => candidate.name === project.name && candidate.id !== currentProjectId);
+      if (!uploadedProject) {
+        return project;
+      }
+      return {
+        ...project,
+        id: uploadedProject.id
+      };
+    });
+  }
+  async fetchCloudProjects(config, solutionId) {
+    const cloudProjects = await getStudioWebSolutionProjects(config, config.organizationName, solutionId);
+    if (cloudProjects === undefined) {
+      throw new Error(`Solution ${solutionId} was not found in Studio Web. Upload it first with 'uip solution upload', or pass --solution-id and --project-id explicitly.`);
+    }
+    return cloudProjects;
+  }
+  mapDesignIdToCloudProjectId(cloudProjects, designProjectId, projectName, solutionId) {
+    const match = cloudProjects.find((project) => project.designId === designProjectId) ?? cloudProjects.find((project) => project.name === projectName);
+    if (!match) {
+      const available = cloudProjects.map((project) => `${project.name ?? "?"} (${project.id})`).join(", ");
+      throw new Error(`Project "${projectName}" (design ID ${designProjectId}) is not part of solution ${solutionId} in Studio Web. Available projects: ${available || "none"}. Re-upload the solution with 'uip solution upload' or pass --project-id.`);
+    }
+    return match.id;
+  }
+  async resolveAdditionalProjects(currentProjectId, flowContent, uipxProjects, solutionStorage, currentDesignProjectId, cloudProjects) {
+    const byId = new Map;
+    for (const project of extractInlineAgentProjects(flowContent, currentProjectId)) {
+      byId.set(project.id, project);
+    }
+    for (const project of uipxProjects) {
+      if (project.Id === currentDesignProjectId) {
+        continue;
+      }
+      const storageProject = solutionStorage?.Projects?.find((storage) => storage.ProjectId === project.Id || storage.ProjectRelativePath === project.ProjectRelativePath);
+      const id = storageProject?.CloudProjectId ?? storageProject?.ProjectId ?? cloudProjects?.find((cloudProject) => cloudProject.designId === project.Id)?.id ?? project.Id;
+      if (id === currentProjectId || byId.has(id)) {
+        continue;
+      }
+      byId.set(id, {
+        id,
+        name: this.fs.path.basename(this.fs.path.dirname(project.ProjectRelativePath)),
+        type: project.Type
+      });
+    }
+    return Array.from(byId.values()).filter((p) => isUUID(p.id));
+  }
+  async resolveEntrypoint(projectPath, evalSet, entryPointOverride) {
+    if (entryPointOverride && (entryPointOverride.startsWith("/") || entryPointOverride.includes("#"))) {
+      return entryPointOverride;
+    }
+    const flowFilePath = await this.pathResolver.findFlowFile(projectPath);
+    const flowFileName = this.fs.path.basename(flowFilePath);
+    const bpmnFileName = flowFileName.replace(/\.flow$/i, ".bpmn");
+    const flowContent = String(await this.fs.readFile(flowFilePath, "utf-8"));
+    const nodeId = entryPointOverride ?? evalSet.selectedEntrypoint ?? readStartNodeId(flowContent) ?? "start";
+    return `/${bpmnFileName}#${nodeId}`;
+  }
+  async readLocalProjectId(projectPath) {
+    const localIdPath = this.fs.path.join(projectPath, ".uipath", "local-project-id.json");
+    if (!await this.fs.exists(localIdPath)) {
+      return;
+    }
+    const [readError, content] = await catchError(this.fs.readFile(localIdPath, "utf-8"));
+    if (readError) {
+      return;
+    }
+    const [parseError, parsed] = catchError(() => JSON.parse(String(content)));
+    if (parseError || !isRecord(parsed)) {
+      return;
+    }
+    return typeof parsed.projectId === "string" && isUUID(parsed.projectId) ? parsed.projectId : undefined;
+  }
+  async readLocalWorkspaceMarker(solutionDir) {
+    const markerPath = this.fs.path.join(solutionDir, ".sw-path-marker");
+    if (!await this.fs.exists(markerPath)) {
+      return;
+    }
+    const content = String(await this.fs.readFile(markerPath, "utf-8"));
+    const solutionId = content.trim();
+    return {
+      SolutionId: isUUID(solutionId) ? solutionId : undefined
+    };
+  }
+  resolveSolutionName(solutionDir, uipxResult) {
+    if (uipxResult?.uipxFileName) {
+      return uipxResult.uipxFileName.replace(/\.uipx$/i, "");
+    }
+    return this.fs.path.basename(solutionDir);
+  }
+  async readSolutionStorage(solutionDir) {
+    const storagePath = this.fs.path.join(solutionDir, "SolutionStorage.json");
+    if (!await this.fs.exists(storagePath)) {
+      return;
+    }
+    const content = await this.fs.readFile(storagePath, "utf-8");
+    const parsed = JSON.parse(String(content));
+    if (!isRecord(parsed)) {
+      throw new Error("SolutionStorage.json must be a JSON object");
+    }
+    const projects = Array.isArray(parsed.Projects) ? parsed.Projects.filter(isRecord).map((project) => ({
+      ProjectId: typeof project.ProjectId === "string" ? project.ProjectId : undefined,
+      ProjectRelativePath: typeof project.ProjectRelativePath === "string" ? project.ProjectRelativePath : undefined,
+      CloudProjectId: typeof project.CloudProjectId === "string" ? project.CloudProjectId : undefined
+    })) : undefined;
+    return {
+      SolutionId: typeof parsed.SolutionId === "string" ? parsed.SolutionId : undefined,
+      ...projects ? { Projects: projects } : {}
+    };
+  }
+}
+
+// src/services/inject-workload-id.ts
+function injectWorkloadId(simulation, defaultWorkloadId) {
+  const workloadId = typeof simulation.workloadId === "string" ? simulation.workloadId : defaultWorkloadId;
+  const childSimulations = Array.isArray(simulation.childSimulations) ? simulation.childSimulations.map((child) => injectWorkloadId(child, workloadId)) : undefined;
+  return {
+    ...simulation,
+    workloadId,
+    ...childSimulations ? { childSimulations } : {}
+  };
+}
+
+// src/services/flow-eval-run-service.ts
+class FlowEvalRunService {
+  fs;
+  api;
+  store;
+  pathResolver;
+  contextResolver;
+  constructor(fs = getFileSystem(), api = new FlowEvalRunApi) {
+    this.fs = fs;
+    this.api = api;
+    this.store = new FlowEvalFileStore(fs);
+    this.pathResolver = new FlowEvalPathResolver(fs);
+    this.contextResolver = new FlowEvalRunContextResolver(fs, this.pathResolver);
+  }
+  async resolveRemoteEvalTarget(projectPath, setIdOrName, options = {}, requireSolutionId = false, config) {
+    const absoluteProjectPath = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const evalSet = await this.requireEvalSet(absoluteProjectPath, setIdOrName);
+    return this.contextResolver.resolveTarget(absoluteProjectPath, evalSet, options, requireSolutionId, config);
+  }
+  async resolveRemoteEvalContext(projectPath, setIdOrName, config, options = {}) {
+    const target = await this.resolveRemoteEvalTarget(projectPath, setIdOrName, options, true, config);
+    const context = await this.contextResolver.buildExecutionContext(target, config, options);
+    return {
+      evalSet: target.evalSet,
+      target,
+      context
+    };
+  }
+  async startRemoteEvalRun(projectPath, setIdOrName, config, options = {}) {
+    const absoluteProjectPath = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const evalSet = await this.requireEvalSet(absoluteProjectPath, setIdOrName);
+    if (evalSet.evaluations.length === 0) {
+      throw new Error(`Evaluation set "${evalSet.name}" has no data points. Add some with 'maestro flow eval add'.`);
+    }
+    const evaluators = await this.getLinkedEvaluators(absoluteProjectPath, evalSet);
+    if (evaluators.length === 0) {
+      throw new Error("No evaluators found for this evaluation set. Add evaluators first.");
+    }
+    const { context } = await this.resolveRemoteEvalContext(absoluteProjectPath, setIdOrName, config, options);
+    const response = await this.api.executeAndEvaluate(config, {
+      workloadId: context.workloadId,
+      context: {
+        type: "Offline",
+        evalSetId: evalSet.id
+      },
+      evaluatorConfigs: evaluators.map((evaluator) => ({
+        id: evaluator.id,
+        version: evaluator.version,
+        evaluatorTypeId: evaluator.evaluatorTypeId,
+        evaluatorConfig: evaluator.evaluatorConfig ?? {}
+      })),
+      items: evalSet.evaluations.map((evaluation) => ({
+        id: evaluation.id,
+        name: evaluation.name,
+        inputs: evaluation.inputs,
+        expectedOutput: evaluation.expectedOutput,
+        evaluationCriterias: evaluation.evaluationCriterias ?? {},
+        simulations: evaluation.simulations?.map((simulation) => injectWorkloadId(simulation, context.workloadId))
+      })),
+      batchSize: evalSet.batchSize ?? 1,
+      ...evalSet.timeoutMinutes !== undefined ? { timeoutMinutes: evalSet.timeoutMinutes } : {},
+      executionConfig: {
+        workloadType: "Flow",
+        tenantId: config.tenantId,
+        folderKey: context.folderKey,
+        entrypoint: context.entrypoint,
+        solutionId: context.solutionId,
+        studioWebProjectId: context.studioWebProjectId,
+        ...context.additionalProjects ? { additionalProjects: context.additionalProjects } : {},
+        ...context.debugMode !== undefined ? { debugMode: context.debugMode } : {}
+      }
+    });
+    const evalSetRunId = response.evalSetRunId;
+    if (typeof evalSetRunId !== "string") {
+      throw new Error("Unified eval API response did not include evalSetRunId.");
+    }
+    return {
+      evalSetRunId,
+      evalSetName: evalSet.name,
+      status: typeof response.status === "string" ? response.status : "Pending",
+      dataPoints: evalSet.evaluations.length,
+      evaluators: evaluators.length,
+      context
+    };
+  }
+  async listRemoteEvalSetRuns(config, workloadId, evalSetId) {
+    const runs = await this.api.listEvalSetRuns(config, workloadId);
+    return evalSetId ? runs.filter((run) => run.evalSetId === evalSetId) : runs;
+  }
+  getRemoteEvalSetRun(config, workloadId, evalSetRunId) {
+    return this.api.getEvalSetRun(config, workloadId, evalSetRunId);
+  }
+  getRemoteEvalRuns(config, workloadId, evalSetRunId) {
+    return this.api.getEvalRuns(config, workloadId, evalSetRunId);
+  }
+  async listEvaluators(projectPath) {
+    const absoluteProjectPath = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    return this.listEvaluatorsForResolvedPath(absoluteProjectPath);
+  }
+  async listEvalSets(projectPath) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return [];
+    }
+    return this.store.readJsonFiles(this.fs.path.join(root, "eval-sets"));
+  }
+  async listEvaluatorsForResolvedPath(projectPath) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return [];
+    }
+    return this.store.readJsonFiles(this.fs.path.join(root, "evaluators"));
+  }
+  async requireEvalSet(projectPath, idOrName) {
+    const evalSet = findEvalSet(await this.listEvalSets(projectPath), idOrName);
+    if (!evalSet) {
+      throw new Error(`Evaluation set "${idOrName}" not found`);
+    }
+    return evalSet;
+  }
+  async getLinkedEvaluators(projectPath, evalSet) {
+    return getLinkedEvaluators(await this.listEvaluatorsForResolvedPath(projectPath), evalSet);
+  }
+}
+export {
+  FlowEvalRunService
+};
+
+//# debugId=F5732D840B9EB53664756E2164756E21