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

package/dist/flow-eval-service-ft8e16jz.js

@@ -0,0 +1,1338 @@
+import {
+  FlowEvalPathResolver,
+  findEvalSet,
+  findEvaluator,
+  getLinkedEvaluators,
+  removeEvaluatorRefFromSet
+} from "./packager-tool-r0xpcqwg.js";
+import {
+  FlowAgentNodeSchemaReader,
+  findFlowNode,
+  isDocumentEvalNode,
+  isNodeEvalTarget,
+  readNodeTargetId
+} from "./packager-tool-g0eha8ge.js";
+import {
+  buildDefaultCriteria,
+  buildEvaluatorConfig,
+  isRecord,
+  slugify
+} from "./packager-tool-8j92afwp.js";
+import {
+  FlowEvalFileStore
+} from "./packager-tool-jc34wvrw.js";
+import {
+  evaluatorTypeAliases,
+  resolveEvaluatorType
+} from "./packager-tool-a1hbfmws.js";
+import"./packager-tool-8dszjcg5.js";
+import"./packager-tool-eebq62fq.js";
+import"./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 {
+  catchError
+} from "./packager-tool-5qaxht3k.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-vpqyvh4c.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-58q3tvh7.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-m5qfverj.js";
+import"./packager-tool-e0p2zsyc.js";
+import"./packager-tool-a42jnpy5.js";
+import"./packager-tool-c23zrhj8.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// src/services/flow-child-simulation-schema.ts
+var AGENT_TOOL_NODE_TYPE_PREFIX = "uipath.agent.resource.tool.";
+function nameMatchesId(name, id) {
+  return name === id || sanitizeToolName(name) === id;
+}
+function readStringField(obj, ...keys) {
+  for (const key of keys) {
+    if (typeof obj[key] === "string")
+      return obj[key];
+  }
+  return;
+}
+
+class ChildSimulationSchemaReader {
+  fs;
+  pathResolver;
+  constructor(fs, pathResolver) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+  }
+  async read(projectPath, parentComponentId, childComponentId, authConfig) {
+    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
+    if (flowError || !flowFilePath) {
+      return { parentFound: false };
+    }
+    const flowContent = String(await this.fs.readFile(flowFilePath, "utf-8"));
+    let parsed;
+    try {
+      parsed = JSON.parse(flowContent);
+    } catch {
+      return { parentFound: false };
+    }
+    if (!isRecord(parsed)) {
+      return { parentFound: false };
+    }
+    const subflows = isRecord(parsed.subflows) ? Object.values(parsed.subflows) : [];
+    const subflowNodes = subflows.flatMap((s) => isRecord(s) && Array.isArray(s.nodes) ? s.nodes : []);
+    const subflowEdges = subflows.flatMap((s) => isRecord(s) && Array.isArray(s.edges) ? s.edges : []);
+    const nodes = [
+      ...Array.isArray(parsed.nodes) ? parsed.nodes : [],
+      ...subflowNodes
+    ];
+    const edges = [
+      ...Array.isArray(parsed.edges) ? parsed.edges : [],
+      ...subflowEdges
+    ];
+    const definitions = Array.isArray(parsed.definitions) ? parsed.definitions : [];
+    const parentNode = nodes.find((n) => isRecord(n) && n.id === parentComponentId);
+    if (!parentNode) {
+      return { parentFound: false };
+    }
+    const agentKind = getAgentKind(parentNode, definitions);
+    switch (agentKind.kind) {
+      case "inlineCanvas":
+        return resolveInlineCanvasSchema(parentComponentId, childComponentId, nodes, edges, definitions);
+      case "sameSolution":
+        return this.resolveSameSolutionSchema(flowFilePath, agentKind.projectId, childComponentId);
+      case "published":
+        return this.resolvePublishedAgentSchema(agentKind.processKey, agentKind.processVersion, childComponentId, authConfig);
+      case "unsupported":
+        return { parentFound: true };
+    }
+  }
+  async resolveSameSolutionSchema(flowFilePath, projectId, childComponentId) {
+    if (/[/\\.]/.test(projectId)) {
+      return { parentFound: true };
+    }
+    const agentJsonPath = this.fs.path.join(this.fs.path.dirname(flowFilePath), projectId, "agent.json");
+    const [readError, raw] = await catchError(this.fs.readFile(agentJsonPath, "utf-8"));
+    if (readError) {
+      return { parentFound: true };
+    }
+    let agent;
+    try {
+      agent = JSON.parse(String(raw));
+    } catch {
+      return { parentFound: true };
+    }
+    if (!isRecord(agent)) {
+      return { parentFound: true };
+    }
+    const resources = Array.isArray(agent.resources) ? agent.resources : [];
+    const schema = findToolSchemaInResources(resources, childComponentId);
+    return { parentFound: true, schema };
+  }
+  async resolvePublishedAgentSchema(processKey, processVersion, childComponentId, authConfig) {
+    if (!authConfig) {
+      const [authError, resolved] = await catchError(resolveAuthFromLogin());
+      if (authError || !resolved) {
+        return { parentFound: true };
+      }
+      authConfig = resolved;
+    }
+    const [fetchError, components] = await catchError(fetchSimulatableComponents(authConfig, processKey, processVersion));
+    if (fetchError || !components) {
+      return { parentFound: true };
+    }
+    const match = components.find((c) => c.id === childComponentId || nameMatchesId(c.name, childComponentId));
+    if (!match?.outputSchema) {
+      return { parentFound: true };
+    }
+    return { parentFound: true, schema: match.outputSchema };
+  }
+}
+async function resolveAuthFromLogin() {
+  const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+  const login = await getLoginStatusAsync();
+  if (login.loginStatus !== "Logged in" || !login.baseUrl || !login.organizationId || !login.tenantId || !login.tenantName || !login.accessToken) {
+    throw new Error("Not logged in");
+  }
+  return {
+    baseUrl: login.baseUrl,
+    organizationId: login.organizationId,
+    tenantId: login.tenantId,
+    tenantName: login.tenantName,
+    authToken: login.accessToken
+  };
+}
+async function fetchSimulatableComponents(config, processKey, processVersion) {
+  const base = `${config.baseUrl}/${config.organizationId}/${config.tenantName}/agentsruntime_/api`;
+  const params = new URLSearchParams({ workloadType: "Agents" });
+  if (processVersion) {
+    params.set("processVersion", processVersion);
+  }
+  const url = `${base}/unifiedEvals/processes/${encodeURIComponent(processKey)}/simulatableComponents?${params.toString()}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${config.authToken}`,
+      Accept: "application/json",
+      "X-UiPath-Internal-TenantId": config.tenantId,
+      "X-UiPath-Internal-AccountId": config.organizationId
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Simulatable components API returned ${response.status}`);
+  }
+  const data = await response.json();
+  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);
+}
+function isAgentNodeType(nodeType) {
+  if (!nodeType)
+    return false;
+  const lower = nodeType.toLowerCase();
+  if (lower.startsWith("uipath.agent.resource.tool."))
+    return false;
+  return lower === "agent" || lower.startsWith("uipath.agent") || lower.startsWith("uipath.core.agent");
+}
+function getAgentKind(node, definitions) {
+  const nodeType = typeof node.type === "string" ? node.type : undefined;
+  const definition = findDefinitionForNode(node, definitions);
+  const defType = isRecord(definition) && typeof definition.nodeType === "string" ? definition.nodeType : undefined;
+  const isAgent = isAgentNodeType(nodeType) || isAgentNodeType(defType);
+  if (!isAgent) {
+    return { kind: "unsupported" };
+  }
+  const projectId = readProjectId(node, definition);
+  if (projectId) {
+    return { kind: "sameSolution", projectId };
+  }
+  if (nodeType?.startsWith("uipath.agent")) {
+    return { kind: "inlineCanvas" };
+  }
+  if (nodeType?.startsWith("uipath.core.agent.")) {
+    const processKey = nodeType.split(".").at(-1) ?? "";
+    if (!processKey)
+      return { kind: "unsupported" };
+    const defRecord = isRecord(definition) ? definition : undefined;
+    const processVersion = typeof defRecord?.version === "string" ? defRecord.version : undefined;
+    return { kind: "published", processKey, processVersion };
+  }
+  return { kind: "unsupported" };
+}
+function readProjectId(node, definition) {
+  const inputs = isRecord(node.inputs) ? node.inputs : undefined;
+  if (typeof inputs?.source === "string" && inputs.source.trim()) {
+    return inputs.source.trim();
+  }
+  const model = isRecord(node.model) ? node.model : undefined;
+  const defRecord = isRecord(definition) ? definition : undefined;
+  const defModel = isRecord(defRecord?.model) ? defRecord.model : undefined;
+  for (const candidate of [
+    model?.projectId,
+    defModel?.projectId,
+    node.projectId,
+    defRecord?.projectId
+  ]) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return;
+}
+function findDefinitionForNode(node, definitions) {
+  const nodeType = typeof node.type === "string" ? node.type : undefined;
+  if (!nodeType)
+    return;
+  return definitions.find((def) => isRecord(def) && def.nodeType === nodeType);
+}
+function resolveInlineCanvasSchema(parentComponentId, childComponentId, nodes, edges, definitions) {
+  const childNodeIds = new Set;
+  for (const edge of edges) {
+    if (!isRecord(edge))
+      continue;
+    const source = readStringField(edge, "sourceNodeId", "source");
+    if (source !== parentComponentId)
+      continue;
+    const target = readStringField(edge, "targetNodeId", "target");
+    if (target) {
+      childNodeIds.add(target);
+    }
+  }
+  for (const n of nodes) {
+    if (!isRecord(n))
+      continue;
+    if (typeof n.id !== "string" || !childNodeIds.has(n.id))
+      continue;
+    if (n.id !== childComponentId && !matchesComponentId(n, childComponentId)) {
+      continue;
+    }
+    const definition = findDefinitionForNode(n, definitions);
+    const schema = extractToolOutputSchema(n, definition);
+    if (schema) {
+      return { parentFound: true, schema };
+    }
+  }
+  return { parentFound: true };
+}
+function matchesComponentId(node, componentId) {
+  const display = isRecord(node.display) ? node.display : undefined;
+  const label = typeof display?.label === "string" ? display.label : undefined;
+  if (label && nameMatchesId(label, componentId))
+    return true;
+  const inputs = isRecord(node.inputs) ? node.inputs : undefined;
+  const name = typeof inputs?.name === "string" ? inputs.name : undefined;
+  if (name && nameMatchesId(name, componentId))
+    return true;
+  return false;
+}
+function sanitizeToolName(name) {
+  return name.replace(/\s+/g, "_").replace(/[^\w-]/g, "").slice(0, 64);
+}
+function extractToolOutputSchema(node, definition) {
+  const nodeType = typeof node.type === "string" ? node.type : "";
+  const outputs = isRecord(node.outputs) ? node.outputs : undefined;
+  if (outputs) {
+    const output = isRecord(outputs.output) ? outputs.output : undefined;
+    if (output?.schema)
+      return output.schema;
+    if (Object.keys(outputs).length > 0) {
+      return { type: "object", properties: outputs };
+    }
+  }
+  const inputs = isRecord(node.inputs) ? node.inputs : undefined;
+  if (inputs?.outputSchema)
+    return inputs.outputSchema;
+  if (nodeType.startsWith("uipath.connector.") || nodeType.startsWith(AGENT_TOOL_NODE_TYPE_PREFIX)) {
+    const schema = extractConnectorOutputSchema(inputs);
+    if (schema)
+      return schema;
+  }
+  if (isRecord(definition)) {
+    const outputDef = isRecord(definition.outputDefinition) ? definition.outputDefinition : undefined;
+    if (outputDef) {
+      const outputEntry = isRecord(outputDef.output) ? outputDef.output : undefined;
+      if (outputEntry?.schema)
+        return outputEntry.schema;
+      if (outputEntry)
+        return outputEntry;
+      if (Object.keys(outputDef).length > 0) {
+        return { type: "object", properties: outputDef };
+      }
+    }
+  }
+  return;
+}
+function extractConnectorOutputSchema(inputs) {
+  if (!inputs)
+    return;
+  const detail = inputs.detail;
+  let detailObj;
+  if (typeof detail === "string") {
+    try {
+      const parsed = JSON.parse(detail);
+      detailObj = isRecord(parsed) ? parsed : undefined;
+    } catch {
+      return;
+    }
+  } else if (isRecord(detail)) {
+    detailObj = detail;
+  }
+  if (!detailObj)
+    return;
+  const config = isRecord(detailObj.configuration) ? detailObj.configuration : undefined;
+  if (!config)
+    return;
+  const fieldsContainer = isRecord(config.fieldsContainer) ? config.fieldsContainer : undefined;
+  if (!fieldsContainer)
+    return;
+  const schema = fieldsContainer.outputJsonSchema;
+  return isRecord(schema) ? schema : undefined;
+}
+function findToolSchemaInResources(resources, childComponentId) {
+  for (const resource of resources) {
+    if (!isRecord(resource))
+      continue;
+    const availableTools = resource.availableTools ?? (isRecord(resource.inputs) ? resource.inputs.selectedTools : undefined);
+    if (Array.isArray(availableTools)) {
+      for (const tool of availableTools) {
+        if (!isRecord(tool))
+          continue;
+        const toolName = typeof tool.name === "string" ? tool.name : undefined;
+        if (!toolName)
+          continue;
+        if (nameMatchesId(toolName, childComponentId)) {
+          if (tool.outputSchema)
+            return tool.outputSchema;
+        }
+      }
+    }
+    const resourceType = typeof resource.$resourceType === "string" ? resource.$resourceType : undefined;
+    const nodeType = readStringField(resource, "nodeType", "type");
+    const isToolLike = nodeType?.startsWith(AGENT_TOOL_NODE_TYPE_PREFIX) || resourceType === "tool" || resourceType === "mcp";
+    if (!isToolLike)
+      continue;
+    const display = isRecord(resource.display) ? resource.display : undefined;
+    const label = typeof display?.label === "string" ? display.label : undefined;
+    const inputs = isRecord(resource.inputs) ? resource.inputs : undefined;
+    const name = (inputs ? readStringField(inputs, "name") : undefined) ?? readStringField(resource, "name");
+    const candidateName = name ?? label;
+    if (!candidateName)
+      continue;
+    if (nameMatchesId(candidateName, childComponentId)) {
+      if (inputs?.outputSchema)
+        return inputs.outputSchema;
+      if (resource.outputSchema)
+        return resource.outputSchema;
+    }
+  }
+  return;
+}
+
+// src/services/flow-eval-files.ts
+import { randomUUID } from "node:crypto";
+var EVAL_FILES_DIR = "eval-files";
+var TOKEN_LENGTH = 12;
+var EVALUATION_BINARY_PREFIX = "BINARY_FILE:";
+var EVALUATION_BINARY_DELIMITER = `
+---BASE64---
+`;
+var TEXT_EXTENSIONS = new Set([
+  ".json",
+  ".csv",
+  ".tsv",
+  ".txt",
+  ".md",
+  ".log",
+  ".xml",
+  ".html",
+  ".htm",
+  ".yaml",
+  ".yml"
+]);
+var MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  ".webp": "image/webp",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".csv": "text/csv",
+  ".tsv": "text/tab-separated-values",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".log": "text/plain",
+  ".xml": "application/xml",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".yaml": "application/yaml",
+  ".yml": "application/yaml"
+};
+
+class FlowEvalFiles {
+  fs;
+  pathResolver;
+  constructor(fs, pathResolver) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+  }
+  async materialize(projectPath, sourcePath) {
+    const projectRoot = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const sourceAbsolute = this.fs.path.resolve(sourcePath);
+    if (!await this.fs.exists(sourceAbsolute)) {
+      throw new Error(`Input file not found: ${sourcePath}`);
+    }
+    const content = await this.fs.readFile(sourceAbsolute);
+    if (content === null) {
+      throw new Error(`Could not read input file: ${sourcePath}`);
+    }
+    const fullName = this.fs.path.basename(sourceAbsolute);
+    const evalRoot = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const dir = this.fs.path.join(evalRoot, EVAL_FILES_DIR);
+    await this.fs.mkdir(dir);
+    const targetName = await this.resolveTargetName(dir, fullName);
+    const targetPath = this.fs.path.join(dir, targetName);
+    const mimeType = mimeFromExt(extOf(fullName));
+    if (TEXT_EXTENSIONS.has(extOf(fullName))) {
+      await this.fs.writeFile(targetPath, content);
+    } else {
+      await this.fs.writeFile(targetPath, encodeBinaryEnvelope(content, mimeType));
+    }
+    const relative = this.fs.path.relative(projectRoot, targetPath).replaceAll("\\", "/");
+    return {
+      ID: `/${relative}`,
+      FullName: fullName,
+      MimeType: mimeType
+    };
+  }
+  async resolveTargetName(dir, fullName) {
+    if (!await this.fs.exists(this.fs.path.join(dir, fullName))) {
+      return fullName;
+    }
+    const ext = extOf(fullName);
+    const stem = ext ? fullName.slice(0, -ext.length) : fullName;
+    const token = randomUUID().replaceAll("-", "").slice(0, TOKEN_LENGTH);
+    return `${stem}_${token}${ext}`;
+  }
+}
+function encodeBinaryEnvelope(content, mimeType) {
+  const base64Content = Buffer.from(content).toString("base64");
+  return `${EVALUATION_BINARY_PREFIX}${mimeType}:${content.byteLength}${EVALUATION_BINARY_DELIMITER}${base64Content}`;
+}
+function extOf(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) {
+    return "";
+  }
+  return name.slice(dot).toLowerCase();
+}
+function mimeFromExt(ext) {
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+
+// src/services/flow-eval-input-schema.ts
+class FlowEvalInputSchema {
+  fs;
+  pathResolver;
+  constructor(fs, pathResolver) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+  }
+  async read(projectPath) {
+    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
+    if (flowError || !flowFilePath) {
+      return {
+        flowFound: false,
+        bpmnFound: false,
+        inputs: new Map
+      };
+    }
+    const flowContent = String(await this.fs.readFile(flowFilePath, "utf-8"));
+    const inputs = readFlowGlobalsAsInputs(flowContent);
+    const bpmnFilePath = flowFilePath.replace(/\.flow$/i, ".bpmn");
+    if (!await this.fs.exists(bpmnFilePath)) {
+      return { flowFound: true, bpmnFound: false, inputs };
+    }
+    const bpmnContent = String(await this.fs.readFile(bpmnFilePath, "utf-8"));
+    annotateBpmnState(inputs, bpmnContent);
+    return { flowFound: true, bpmnFound: true, inputs };
+  }
+}
+function readFlowGlobalsAsInputs(flowContent) {
+  const inputs = new Map;
+  let parsed;
+  try {
+    parsed = JSON.parse(flowContent);
+  } catch {
+    return inputs;
+  }
+  if (!isRecord(parsed)) {
+    return inputs;
+  }
+  const variables = isRecord(parsed.variables) ? parsed.variables : undefined;
+  const globals = Array.isArray(variables?.globals) ? variables.globals : [];
+  for (const entry of globals) {
+    if (!isRecord(entry)) {
+      continue;
+    }
+    if (entry.direction !== "in" || typeof entry.id !== "string") {
+      continue;
+    }
+    const type = typeof entry.type === "string" ? entry.type : "unknown";
+    inputs.set(entry.id, {
+      type,
+      inBpmn: false,
+      bpmnHasJobAttachmentTarget: false
+    });
+  }
+  return inputs;
+}
+function annotateBpmnState(inputs, bpmnContent) {
+  for (const [key, value] of inputs) {
+    const declared = new RegExp(`<uipath:input\\b[^>]*\\bid="${escapeRegex(key)}"`).test(bpmnContent);
+    const jobAttachment = new RegExp(`<uipath:output\\b[^>]*\\bsource="=vars\\.${escapeRegex(key)}"[^>]*\\btarget="=orchestrator\\.JobAttachments"`).test(bpmnContent);
+    inputs.set(key, {
+      ...value,
+      inBpmn: declared,
+      bpmnHasJobAttachmentTarget: jobAttachment
+    });
+  }
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/services/flow-eval-set-crud.ts
+var DATASET_SCHEMA_VERSION = 4;
+
+class FlowEvalSetCrud {
+  fs;
+  store;
+  pathResolver;
+  constructor(fs, store, pathResolver) {
+    this.fs = fs;
+    this.store = store;
+    this.pathResolver = pathResolver;
+  }
+  async list(projectPath) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return [];
+    }
+    return this.store.readJsonFiles(this.fs.path.join(root, "eval-sets"));
+  }
+  async add(projectPath, options) {
+    const resolvedProjectPath = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const id = crypto.randomUUID();
+    const fileName = `evaluation-set-${slugify(options.name)}-${id.slice(0, 8)}.json`;
+    const evaluators = await this.store.readJsonFiles(this.fs.path.join(root, "evaluators"));
+    const now = new Date().toISOString();
+    const agentNodeId = await this.resolveAgentNodeTarget(resolvedProjectPath, options.entryPoint);
+    const selectedEntrypoint = options.entryPoint ?? await this.pathResolver.readDefaultEntryPointNodeId(resolvedProjectPath);
+    const evalSet = {
+      version: "1.0",
+      ...agentNodeId !== undefined ? { schemaVersion: DATASET_SCHEMA_VERSION } : {},
+      id,
+      name: options.name,
+      evaluatorRefs: options.evaluatorRefs ?? evaluators.map((evaluator) => evaluator.fileName ?? `${evaluator.id}.json`),
+      evaluations: [],
+      ...agentNodeId !== undefined ? {
+        target: {
+          kind: "agentNode",
+          nodeId: agentNodeId
+        },
+        nodeEval: true
+      } : {},
+      ...selectedEntrypoint !== undefined ? { selectedEntrypoint } : {},
+      fileName,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.store.writeJsonFile(this.fs.path.join(root, "eval-sets", fileName), evalSet);
+    return evalSet;
+  }
+  async resolveAgentNodeTarget(resolvedProjectPath, entryPoint) {
+    if (entryPoint === undefined || entryPoint.includes("/") || entryPoint.includes("#")) {
+      return;
+    }
+    const [findError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(resolvedProjectPath));
+    if (findError || !flowFilePath) {
+      return;
+    }
+    const [readError, flowContent] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    if (readError) {
+      return;
+    }
+    const lookup = findFlowNode(String(flowContent), entryPoint);
+    if (!lookup.flowParsed) {
+      return;
+    }
+    if (!lookup.node) {
+      throw new Error(`Entry point "${entryPoint}" does not match any node in the flow. Pass a node id from the .flow file (an agent node id creates a node-scoped eval set), or omit --entry-point to use the default start node.`);
+    }
+    if (isDocumentEvalNode(lookup.node)) {
+      throw new Error(`Entry point "${entryPoint}" is a document node — document-scoped eval sets are not supported by the CLI yet. Create them in Studio Web, or target the flow or an agent node instead.`);
+    }
+    return isNodeEvalTarget(lookup.node) ? entryPoint : undefined;
+  }
+  async remove(projectPath, idOrName) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evalSet = findEvalSet(await this.list(projectPath), idOrName);
+    if (!evalSet?.fileName) {
+      return false;
+    }
+    await this.store.remove(this.fs.path.join(root, "eval-sets", evalSet.fileName));
+    return true;
+  }
+}
+
+// src/services/flow-evaluation-crud.ts
+class FlowEvaluationCrud {
+  fs;
+  store;
+  pathResolver;
+  constructor(fs, store, pathResolver) {
+    this.fs = fs;
+    this.store = store;
+    this.pathResolver = pathResolver;
+  }
+  async add(projectPath, setIdOrName, options) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluators = getLinkedEvaluators(await this.listEvaluators(root), evalSet);
+    const now = new Date().toISOString();
+    const evaluation = {
+      id: crypto.randomUUID(),
+      name: options.name,
+      inputs: options.inputs,
+      expectedOutput: options.expectedOutput,
+      evaluationCriterias: options.criteria ?? buildDefaultCriteria(evaluators, options.expectedOutput, options.searchText),
+      createdAt: now,
+      updatedAt: now
+    };
+    evalSet.evaluations.push(evaluation);
+    evalSet.updatedAt = now;
+    await this.writeEvalSet(root, evalSet);
+    return evaluation;
+  }
+  async list(projectPath, setIdOrName) {
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    return evalSet.evaluations;
+  }
+  async addSimulation(projectPath, setIdOrName, evaluationIdOrName, simulation) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    if (!evaluation.simulations) {
+      evaluation.simulations = [];
+    }
+    const existing = evaluation.simulations.findIndex((s) => s.componentId === simulation.componentId);
+    const now = new Date().toISOString();
+    if (existing !== -1) {
+      evaluation.simulations[existing] = simulation;
+    } else {
+      evaluation.simulations.push(simulation);
+    }
+    evaluation.updatedAt = now;
+    evalSet.updatedAt = now;
+    await this.writeEvalSet(root, evalSet);
+    return simulation;
+  }
+  async listSimulations(projectPath, setIdOrName, evaluationIdOrName) {
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    return evaluation.simulations ?? [];
+  }
+  async addChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childSimulation) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    if (!evaluation.simulations) {
+      evaluation.simulations = [];
+    }
+    let parent = evaluation.simulations.find((s) => s.componentId === parentComponentId);
+    if (!parent) {
+      parent = {
+        componentId: parentComponentId,
+        componentType: "agent",
+        simulationStrategy: "Llm",
+        childSimulations: []
+      };
+      evaluation.simulations.push(parent);
+    }
+    if (!parent.childSimulations) {
+      parent.childSimulations = [];
+    }
+    const existing = parent.childSimulations.findIndex((s) => s.componentId === childSimulation.componentId);
+    const now = new Date().toISOString();
+    if (existing !== -1) {
+      parent.childSimulations[existing] = childSimulation;
+    } else {
+      parent.childSimulations.push(childSimulation);
+    }
+    evaluation.updatedAt = now;
+    evalSet.updatedAt = now;
+    await this.writeEvalSet(root, evalSet);
+    return childSimulation;
+  }
+  listChildSimulations(evaluation, parentComponentId) {
+    const parent = (evaluation.simulations ?? []).find((s) => s.componentId === parentComponentId);
+    if (!parent) {
+      throw new Error(`Simulation for component "${parentComponentId}" not found`);
+    }
+    return parent.childSimulations ?? [];
+  }
+  async removeChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childComponentId) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    const parent = (evaluation.simulations ?? []).find((s) => s.componentId === parentComponentId);
+    if (!parent) {
+      throw new Error(`Simulation for component "${parentComponentId}" not found`);
+    }
+    const index = (parent.childSimulations ?? []).findIndex((s) => s.componentId === childComponentId);
+    if (index === -1) {
+      return false;
+    }
+    parent.childSimulations?.splice(index, 1);
+    evalSet.updatedAt = new Date().toISOString();
+    await this.writeEvalSet(root, evalSet);
+    return true;
+  }
+  async removeSimulation(projectPath, setIdOrName, evaluationIdOrName, componentId) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    const index = (evaluation.simulations ?? []).findIndex((s) => s.componentId === componentId);
+    if (index === -1) {
+      return false;
+    }
+    evaluation.simulations?.splice(index, 1);
+    evalSet.updatedAt = new Date().toISOString();
+    await this.writeEvalSet(root, evalSet);
+    return true;
+  }
+  async remove(projectPath, setIdOrName, evaluationIdOrName) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const index = evalSet.evaluations.findIndex((evaluation) => evaluation.id === evaluationIdOrName || evaluation.name === evaluationIdOrName);
+    if (index === -1) {
+      return false;
+    }
+    evalSet.evaluations.splice(index, 1);
+    evalSet.updatedAt = new Date().toISOString();
+    await this.writeEvalSet(root, evalSet);
+    return true;
+  }
+  async requireEvalSet(projectPath, idOrName) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    const evalSet = root ? findEvalSet(await this.listEvalSets(root), idOrName) : null;
+    if (!evalSet) {
+      throw new Error(`Evaluation set "${idOrName}" not found`);
+    }
+    return evalSet;
+  }
+  async listEvalSets(root) {
+    return this.store.readJsonFiles(this.fs.path.join(root, "eval-sets"));
+  }
+  async listEvaluators(root) {
+    return this.store.readJsonFiles(this.fs.path.join(root, "evaluators"));
+  }
+  async writeEvalSet(root, evalSet) {
+    await this.store.writeJsonFile(this.fs.path.join(root, "eval-sets", evalSet.fileName ?? `${evalSet.id}.json`), evalSet);
+  }
+}
+
+// src/services/flow-evaluator-crud.ts
+class FlowEvaluatorCrud {
+  fs;
+  store;
+  pathResolver;
+  constructor(fs, store, pathResolver) {
+    this.fs = fs;
+    this.store = store;
+    this.pathResolver = pathResolver;
+  }
+  async list(projectPath) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return [];
+    }
+    return this.store.readJsonFiles(this.fs.path.join(root, "evaluators"));
+  }
+  async add(projectPath, options) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const typeId = resolveEvaluatorType(options.type);
+    const id = `${slugify(options.name)}-${crypto.randomUUID().slice(0, 8)}`;
+    const now = new Date().toISOString();
+    const fileName = `${id}.json`;
+    const evaluator = {
+      version: "1.0",
+      id,
+      name: options.name,
+      description: options.description ?? `${options.name} evaluator`,
+      evaluatorTypeId: typeId,
+      evaluatorConfig: buildEvaluatorConfig(typeId, options),
+      fileName,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.store.writeJsonFile(this.fs.path.join(root, "evaluators", fileName), evaluator);
+    return evaluator;
+  }
+  async remove(projectPath, idOrName) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evaluator = findEvaluator(await this.list(projectPath), idOrName);
+    if (!evaluator?.fileName) {
+      return false;
+    }
+    await this.store.remove(this.fs.path.join(root, "evaluators", evaluator.fileName));
+    await this.removeEvaluatorRefs(root, evaluator);
+    return true;
+  }
+  async removeEvaluatorRefs(root, evaluator) {
+    const sets = await this.store.readJsonFiles(this.fs.path.join(root, "eval-sets"));
+    for (const set of sets) {
+      if (removeEvaluatorRefFromSet(set, evaluator) && set.fileName) {
+        await this.writeEvalSet(root, set);
+      }
+    }
+  }
+  async writeEvalSet(root, evalSet) {
+    await this.store.writeJsonFile(this.fs.path.join(root, "eval-sets", evalSet.fileName ?? `${evalSet.id}.json`), evalSet);
+  }
+}
+
+// src/services/flow-node-output-schema.ts
+class FlowEvalOutputSchema {
+  fs;
+  pathResolver;
+  constructor(fs, pathResolver) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+  }
+  async read(projectPath) {
+    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
+    if (flowError || !flowFilePath) {
+      return { flowFound: false, outputs: new Map };
+    }
+    const flowContent = String(await this.fs.readFile(flowFilePath, "utf-8"));
+    return {
+      flowFound: true,
+      flowFilePath,
+      outputs: readFlowGlobalsAsOutputs(flowContent)
+    };
+  }
+}
+function readFlowGlobalsAsOutputs(flowContent) {
+  const outputs = new Map;
+  let parsed;
+  try {
+    parsed = JSON.parse(flowContent);
+  } catch {
+    return outputs;
+  }
+  if (!isRecord(parsed))
+    return outputs;
+  const variables = isRecord(parsed.variables) ? parsed.variables : undefined;
+  const globals = Array.isArray(variables?.globals) ? variables.globals : [];
+  for (const entry of globals) {
+    if (!isRecord(entry))
+      continue;
+    if (entry.direction !== "out")
+      continue;
+    if (typeof entry.id !== "string")
+      continue;
+    const type = typeof entry.type === "string" ? entry.type : "unknown";
+    outputs.set(entry.id, { type });
+  }
+  return outputs;
+}
+
+class FlowNodeOutputSchemaReader {
+  fs;
+  pathResolver;
+  constructor(fs, pathResolver) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+  }
+  async read(projectPath, componentId) {
+    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
+    if (flowError || !flowFilePath) {
+      return { schema: undefined, nodeFound: false };
+    }
+    const flowContent = String(await this.fs.readFile(flowFilePath, "utf-8"));
+    return this.extract(flowContent, componentId);
+  }
+  extract(flowContent, componentId) {
+    return extractNodeOutputSchema(flowContent, componentId, false);
+  }
+}
+
+class SimulateFlowOutputSchemaReader extends FlowNodeOutputSchemaReader {
+  extract(flowContent, componentId) {
+    const result = extractNodeOutputSchema(flowContent, componentId, true);
+    if (!result.nodeFound || result.schema === undefined) {
+      return result;
+    }
+    return { ...result, schema: cleanOutputSchema(result.schema) };
+  }
+}
+function extractNodeOutputSchema(flowContent, componentId, wrapAllOutputs) {
+  let parsed;
+  try {
+    parsed = JSON.parse(flowContent);
+  } catch {
+    return { schema: undefined, nodeFound: false };
+  }
+  if (!isRecord(parsed)) {
+    return { schema: undefined, nodeFound: false };
+  }
+  const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  const node = nodes.find((n) => isRecord(n) && n.id === componentId);
+  if (!node) {
+    return { schema: undefined, nodeFound: false };
+  }
+  const nodeType = typeof node.type === "string" ? node.type : "";
+  if (nodeType.startsWith("uipath.connector.")) {
+    const schema = extractConnectorOutputSchema2(node);
+    if (schema) {
+      return { schema, nodeFound: true };
+    }
+  }
+  if (nodeType.startsWith("uipath.agent.")) {
+    const schema = extractAgentOutputSchema(node);
+    if (schema) {
+      return { schema, nodeFound: true };
+    }
+  }
+  const outputs = isRecord(node.outputs) ? node.outputs : undefined;
+  if (outputs && Object.keys(outputs).length > 0) {
+    if (!wrapAllOutputs && "output" in outputs) {
+      return { schema: outputs.output, nodeFound: true };
+    }
+    return {
+      schema: { type: "object", properties: outputs },
+      nodeFound: true
+    };
+  }
+  return { schema: undefined, nodeFound: true };
+}
+function extractConnectorOutputSchema2(node) {
+  if (!isRecord(node.inputs))
+    return;
+  const detail = node.inputs.detail;
+  let detailObj;
+  if (typeof detail === "string") {
+    try {
+      const parsed = JSON.parse(detail);
+      if (!isRecord(parsed))
+        return;
+      detailObj = parsed;
+    } catch {
+      return;
+    }
+  } else if (isRecord(detail)) {
+    detailObj = detail;
+  } else {
+    return;
+  }
+  const config = isRecord(detailObj.configuration) ? detailObj.configuration : undefined;
+  if (!config)
+    return;
+  const fieldsContainer = isRecord(config.fieldsContainer) ? config.fieldsContainer : undefined;
+  if (!fieldsContainer)
+    return;
+  const schema = fieldsContainer.outputJsonSchema;
+  if (!schema || !isRecord(schema))
+    return;
+  return schema;
+}
+function extractAgentOutputSchema(node) {
+  if (!isRecord(node.inputs))
+    return;
+  const agentOutputVariables = node.inputs.agentOutputVariables;
+  if (!Array.isArray(agentOutputVariables) || agentOutputVariables.length === 0) {
+    return;
+  }
+  const properties = {};
+  for (const v of agentOutputVariables) {
+    if (!isRecord(v) || typeof v.id !== "string")
+      continue;
+    const type = typeof v.type === "string" ? v.type : "string";
+    if (isRecord(v.schema)) {
+      properties[v.id] = v.schema;
+    } else {
+      properties[v.id] = { type };
+    }
+  }
+  if (Object.keys(properties).length === 0)
+    return;
+  return { type: "object", properties };
+}
+var ANNOTATION_KEYS = new Set([
+  "title",
+  "description",
+  "default",
+  "source",
+  "var"
+]);
+function cleanOutputSchema(schema) {
+  const stripped = stripAnnotations(schema);
+  return unwrapOutputProperty(stripped);
+}
+function stripAnnotations(value) {
+  if (!isRecord(value))
+    return value;
+  const result = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (ANNOTATION_KEYS.has(k))
+      continue;
+    result[k] = Array.isArray(v) ? v.map(stripAnnotations) : isRecord(v) ? stripAnnotations(v) : v;
+  }
+  return result;
+}
+function unwrapOutputProperty(schema) {
+  if (!isRecord(schema))
+    return schema;
+  const props = isRecord(schema.properties) ? schema.properties : undefined;
+  if (!props || !("output" in props))
+    return schema;
+  return props.output;
+}
+
+// src/services/flow-eval-service.ts
+class FlowEvalService {
+  fs;
+  evaluators;
+  evalSets;
+  evaluations;
+  files;
+  inputSchema;
+  outputSchema;
+  nodeOutputSchema;
+  agentNodeSchema;
+  childSimulationSchema;
+  constructor(fs = getFileSystem()) {
+    this.fs = fs;
+    const store = new FlowEvalFileStore(fs);
+    const pathResolver = new FlowEvalPathResolver(fs);
+    this.evaluators = new FlowEvaluatorCrud(fs, store, pathResolver);
+    this.evalSets = new FlowEvalSetCrud(fs, store, pathResolver);
+    this.evaluations = new FlowEvaluationCrud(fs, store, pathResolver);
+    this.files = new FlowEvalFiles(fs, pathResolver);
+    this.inputSchema = new FlowEvalInputSchema(fs, pathResolver);
+    this.outputSchema = new FlowEvalOutputSchema(fs, pathResolver);
+    this.nodeOutputSchema = new SimulateFlowOutputSchemaReader(fs, pathResolver);
+    this.agentNodeSchema = new FlowAgentNodeSchemaReader(fs, pathResolver);
+    this.childSimulationSchema = new ChildSimulationSchemaReader(fs, pathResolver);
+  }
+  listEvalSets(projectPath) {
+    return this.evalSets.list(projectPath);
+  }
+  listEvaluators(projectPath) {
+    return this.evaluators.list(projectPath);
+  }
+  addEvaluator(projectPath, options) {
+    return this.evaluators.add(projectPath, options);
+  }
+  removeEvaluator(projectPath, idOrName) {
+    return this.evaluators.remove(projectPath, idOrName);
+  }
+  addEvalSet(projectPath, options) {
+    return this.evalSets.add(projectPath, options);
+  }
+  removeEvalSet(projectPath, idOrName) {
+    return this.evalSets.remove(projectPath, idOrName);
+  }
+  async addEvaluation(projectPath, setIdOrName, options) {
+    const inputFiles = options.inputFiles ?? [];
+    for (const file of inputFiles) {
+      if (file.key in options.inputs) {
+        throw new Error(`Input "${file.key}" was provided in both --inputs and --input-file`);
+      }
+    }
+    const evalSet = findEvalSet(await this.evalSets.list(projectPath), setIdOrName);
+    const nodeTargetId = evalSet ? readNodeTargetId(evalSet) : undefined;
+    if (nodeTargetId !== undefined) {
+      if (inputFiles.length > 0) {
+        throw new Error(`File inputs (--input-file) are not supported for node-scoped eval sets yet. Pass the value inline via --inputs, or use a flow-scoped eval set.`);
+      }
+      await this.validateAgentInputKeys(projectPath, nodeTargetId, options.inputs);
+      if (options.expectedOutput) {
+        await this.validateAgentOutputKeys(projectPath, nodeTargetId, options.expectedOutput);
+      }
+    } else {
+      await this.validateInputKeys(projectPath, options.inputs, inputFiles);
+      if (options.expectedOutput) {
+        await this.validateOutputKeys(projectPath, options.expectedOutput);
+      }
+    }
+    const inputs = { ...options.inputs };
+    for (const file of inputFiles) {
+      inputs[file.key] = await this.files.materialize(projectPath, file.sourcePath);
+    }
+    return this.evaluations.add(projectPath, setIdOrName, {
+      ...options,
+      inputs
+    });
+  }
+  async validateInputKeys(projectPath, inputs, inputFiles) {
+    const schema = await this.inputSchema.read(projectPath);
+    if (!schema.flowFound) {
+      return;
+    }
+    for (const key of Object.keys(inputs)) {
+      const declared = schema.inputs.get(key);
+      if (!declared) {
+        throw new Error(`Input "${key}" is not declared as an input variable in the flow. Add it to variables.globals (direction: "in") in new.flow.`);
+      }
+      if (schema.bpmnFound && !declared.inBpmn) {
+        throw new Error(`Input "${key}" is declared in new.flow but missing from new.bpmn. Re-save the project in Studio Web so the BPMN is regenerated.`);
+      }
+    }
+    for (const file of inputFiles) {
+      const declared = schema.inputs.get(file.key);
+      if (!declared) {
+        throw new Error(`Input "${file.key}" is not declared as an input variable in the flow. Add it to variables.globals (direction: "in", type: "file") in new.flow.`);
+      }
+      if (declared.type !== "file") {
+        throw new Error(`Input "${file.key}" is declared with type "${declared.type}" but --input-file requires type "file".`);
+      }
+      if (schema.bpmnFound && !declared.inBpmn) {
+        throw new Error(`Input "${file.key}" is declared in new.flow but missing from new.bpmn. Re-save the project in Studio Web so the BPMN is regenerated.`);
+      }
+      if (schema.bpmnFound && !declared.bpmnHasJobAttachmentTarget) {
+        throw new Error(`Input "${file.key}" is missing the orchestrator.JobAttachments mapping in new.bpmn. Re-save the project in Studio Web so the BPMN is regenerated.`);
+      }
+    }
+  }
+  async validateAgentInputKeys(projectPath, nodeTargetId, inputs) {
+    const schema = await this.agentNodeSchema.read(projectPath, nodeTargetId);
+    if (!schema.agentFound || schema.inputs.length === 0) {
+      return;
+    }
+    const declaredKeys = new Set(schema.inputs.flatMap((leaf) => [leaf.flatKey, leaf.path]));
+    for (const key of Object.keys(inputs)) {
+      if (!declaredKeys.has(key)) {
+        throw new Error(`Input "${key}" is not an input of agent node "${nodeTargetId}". Declared agent inputs: ${schema.inputs.map((leaf) => leaf.flatKey).join(", ")}.`);
+      }
+    }
+  }
+  async validateAgentOutputKeys(projectPath, nodeTargetId, expectedOutput) {
+    const schema = await this.agentNodeSchema.read(projectPath, nodeTargetId);
+    if (!schema.agentFound || schema.outputs.size === 0) {
+      return;
+    }
+    for (const key of Object.keys(expectedOutput)) {
+      if (!schema.outputs.has(key)) {
+        throw new Error(`Output key "${key}" is not an output of agent node "${nodeTargetId}". Declared agent outputs: ${[...schema.outputs].join(", ")}.`);
+      }
+    }
+  }
+  async validateOutputKeys(projectPath, expectedOutput) {
+    const schema = await this.outputSchema.read(projectPath);
+    if (!schema.flowFound || schema.outputs.size === 0) {
+      return;
+    }
+    const flowFile = schema.flowFilePath ? this.fs.path.basename(schema.flowFilePath) : "the .flow file";
+    for (const key of Object.keys(expectedOutput)) {
+      if (!schema.outputs.has(key)) {
+        throw new Error(`Output key "${key}" is not declared as an output variable in the flow. Add it to variables.globals (direction: "out") in ${flowFile}.`);
+      }
+    }
+  }
+  listEvaluations(projectPath, setIdOrName) {
+    return this.evaluations.list(projectPath, setIdOrName);
+  }
+  removeEvaluation(projectPath, setIdOrName, evaluationIdOrName) {
+    return this.evaluations.remove(projectPath, setIdOrName, evaluationIdOrName);
+  }
+  async addSimulation(projectPath, setIdOrName, evaluationIdOrName, simulation) {
+    if (simulation.simulationStrategy === "Llm" && simulation.outputSchema === undefined) {
+      const resolved = await this.nodeOutputSchema.read(projectPath, simulation.componentId);
+      if (!resolved.nodeFound) {
+        throw new Error(`Component "${simulation.componentId}" not found in the flow. Verify the component ID.`);
+      }
+      if (!resolved.schema) {
+        throw new Error(`Could not auto-resolve output schema for component "${simulation.componentId}". The node has no declared outputs.`);
+      }
+      simulation = { ...simulation, outputSchema: resolved.schema };
+    }
+    return this.evaluations.addSimulation(projectPath, setIdOrName, evaluationIdOrName, simulation);
+  }
+  listSimulations(projectPath, setIdOrName, evaluationIdOrName) {
+    return this.evaluations.listSimulations(projectPath, setIdOrName, evaluationIdOrName);
+  }
+  removeSimulation(projectPath, setIdOrName, evaluationIdOrName, componentId) {
+    return this.evaluations.removeSimulation(projectPath, setIdOrName, evaluationIdOrName, componentId);
+  }
+  async addChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childSimulation) {
+    if (childSimulation.outputSchema === undefined) {
+      const resolved = await this.childSimulationSchema.read(projectPath, parentComponentId, childSimulation.componentId);
+      if (resolved.schema) {
+        childSimulation = {
+          ...childSimulation,
+          outputSchema: resolved.schema
+        };
+      } else if (childSimulation.simulationStrategy === "Llm") {
+        if (!resolved.parentFound) {
+          throw new Error(`Parent agent "${parentComponentId}" not found in the flow. Verify the parent component ID.`);
+        }
+        throw new Error(`Could not auto-resolve output schema for "${childSimulation.componentId}" inside agent "${parentComponentId}". ` + `Check that the tool exists on the agent and, for published agents, that you are logged in (uip login).`);
+      }
+    }
+    if (childSimulation.simulationStrategy === "Static" && childSimulation.outputSchema !== undefined && childSimulation.mockValue !== undefined) {
+      validateMockValueKeys(childSimulation.mockValue, childSimulation.outputSchema, childSimulation.componentId);
+    }
+    return this.evaluations.addChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childSimulation);
+  }
+  async listChildSimulations(projectPath, setIdOrName, evaluationIdOrName, parentComponentId) {
+    const evalSet = await this.evaluations.list(projectPath, setIdOrName);
+    const evaluation = evalSet.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    return this.evaluations.listChildSimulations(evaluation, parentComponentId);
+  }
+  removeChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childComponentId) {
+    return this.evaluations.removeChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childComponentId);
+  }
+  static evaluatorTypeAliases() {
+    return evaluatorTypeAliases();
+  }
+}
+function validateMockValueKeys(mockValue, outputSchema, componentId) {
+  if (!isRecord(mockValue) || !isRecord(outputSchema))
+    return;
+  const properties = isRecord(outputSchema.properties) ? outputSchema.properties : undefined;
+  if (!properties)
+    return;
+  const schemaKeys = new Set(Object.keys(properties));
+  const mockKeys = Object.keys(mockValue);
+  const unexpected = mockKeys.filter((k) => !schemaKeys.has(k));
+  if (unexpected.length > 0) {
+    throw new Error(`Mock value for "${componentId}" has keys not in the output schema: ${unexpected.join(", ")}. ` + `Expected keys: ${[...schemaKeys].join(", ")}`);
+  }
+}
+export {
+  FlowEvalService
+};
+
+//# debugId=E80A5885C51852BD64756E2164756E21