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

package/dist/{flow-eval-service-7tpvhn9b.js → flow-eval-service-5j1rwx32.js}

@@ -1,50 +1,58 @@
+import"./packager-tool-s695j0qj.js";
 import {
-  FlowEvalPathResolver,
-  findEvalSet,
-  findEvaluator,
-  getLinkedEvaluators,
-  removeEvaluatorRefFromSet
-} from "./packager-tool-rkv04anh.js";
+  FlowEvalPathResolver
+} from "./packager-tool-vv9cf7n5.js";
 import {
   FlowAgentNodeSchemaReader,
   findFlowNode,
-  formatTriggerIdsHint,
   isDocumentEvalNode,
   isNodeEvalTarget,
-  listTriggerNodeIds,
   readNodeTargetId
-} from "./packager-tool-a0f48rfb.js";
+} from "./packager-tool-42xfgd4y.js";
+import"./packager-tool-n90231c7.js";
+import {
+  formatTriggerIdsHint,
+  listTriggerNodeIds
+} from "./packager-tool-nsh0qg9g.js";
+import"./packager-tool-k7n4sf7v.js";
 import {
-  buildDefaultCriteria,
-  buildEvaluatorConfig,
+  findMatchingDefinition
+} from "./packager-tool-2qywkm61.js";
+import {
+  EvalFileStore,
+  EvalFiles,
+  EvaluationCrud,
+  EvaluatorCrud,
   evaluatorTypeAliases,
-  findMatchingDefinition,
+  findEvalSet,
   isRecord,
   resolveEvalApiConfig,
-  resolveEvaluatorType,
   slugify
-} from "./packager-tool-64zypey6.js";
-import"./packager-tool-7msx23gd.js";
+} from "./packager-tool-m1901c0c.js";
+import"./packager-tool-8tv6dvs5.js";
+import"./packager-tool-1q0ee9ht.js";
+import"./packager-tool-zgm0r4yp.js";
+import"./packager-tool-6sm17vbx.js";
 import {
-  FlowEvalFileStore
-} from "./packager-tool-7t0xj5pz.js";
-import"./packager-tool-kme3q8xv.js";
-import"./packager-tool-j6q8v3kc.js";
-import"./packager-tool-yv10w46z.js";
-import"./packager-tool-x2py933t.js";
-import"./packager-tool-ts5t1nmn.js";
-import"./packager-tool-5jb06280.js";
-import"./packager-tool-kveaemqp.js";
-import"./packager-tool-nase5ajk.js";
+  createFlowRefResolver,
+  resolveWorkflowRefs
+} from "./packager-tool-tzc6xsp3.js";
+import"./packager-tool-sxqtxw0e.js";
+import"./packager-tool-d1kd88zq.js";
+import"./packager-tool-y4tyghzf.js";
+import"./packager-tool-msecps3h.js";
+import"./packager-tool-rp7pny4t.js";
 import"./packager-tool-nkrmjr3a.js";
 import {
   getFileSystem
-} from "./packager-tool-xdxr3ync.js";
+} from "./packager-tool-hdxtgckw.js";
 import"./packager-tool-rs6jm14d.js";
 import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-7q6z6npd.js";
+import"./packager-tool-mgcz986r.js";
+import"./packager-tool-xj0agqpk.js";
+import"./packager-tool-pcvhcn2k.js";
 import"./packager-tool-sc961w0q.js";
-import"./packager-tool-d88rqwk8.js";
+import"./packager-tool-6z1hsm2h.js";
 import"./packager-tool-dxz4sejs.js";
 import"./packager-tool-sztqqbxp.js";
 import"./packager-tool-gbgfwx8f.js";
@@ -58,9 +66,10 @@ import"./packager-tool-mcaf4ewf.js";
 import"./packager-tool-4mna26cc.js";
 import"./packager-tool-c23zrhj8.js";
 import"./packager-tool-yvcrdbgp.js";
+import"./packager-tool-sm8ertv4.js";
 import {
   catchError
-} from "./packager-tool-z1qbc0qf.js";
+} from "./packager-tool-wv85dhy2.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";
@@ -74,7 +83,7 @@ class FlowEvalOutputSchema {
     this.pathResolver = pathResolver;
   }
   async read(projectPath) {
-    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const root = await this.pathResolver.resolveProjectPath(projectPath);
     const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
     if (flowError || !flowFilePath) {
       return { flowFound: false, outputs: new Map };
@@ -120,40 +129,135 @@ class FlowNodeOutputSchemaReader {
     this.pathResolver = pathResolver;
   }
   async read(projectPath, componentId) {
-    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const root = await this.pathResolver.resolveProjectPath(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);
+    const flow = await readResolvedFlow(this.fs, flowFilePath);
+    return this.extract(flow, componentId);
+  }
+  extract(flow, componentId) {
+    return extractNodeOutputSchema(flow, componentId, false);
+  }
+}
+async function readResolvedFlow(fs, flowFilePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(String(await fs.readFile(flowFilePath, "utf-8")));
+  } catch (error) {
+    throw new Error(`Could not parse ${flowFilePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) {
+    throw new Error(`Could not parse ${flowFilePath}: not a JSON object.`);
+  }
+  const missing = [];
+  const resolver = createFlowRefResolver(fs, {
+    warn: (message) => missing.push(message)
+  });
+  const [refError, result] = await catchError(resolveWorkflowRefs(parsed, resolver, flowFilePath));
+  if (refError || missing.length > 0 || !result || !isRecord(result.resolved)) {
+    const reason = refError ? refError.message : missing.length > 0 ? missing.join("; ") : "the resolved flow is not a JSON object";
+    throw new Error(`Could not resolve the $ref chunks of ${flowFilePath}: ${reason}`);
+  }
+  return result.resolved;
+}
+
+class FlowComponentLocator {
+  fs;
+  pathResolver;
+  constructor(fs, pathResolver) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+  }
+  async find(projectPath, componentId) {
+    const none = { flowRead: false, found: false, suggestions: [] };
+    const root = await this.pathResolver.resolveProjectPath(projectPath);
+    const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
+    if (flowError || !flowFilePath)
+      return none;
+    const flow = await readResolvedFlow(this.fs, flowFilePath);
+    const scopes = scopesOfNode(flow, componentId);
+    if (scopes.length > 1) {
+      throw new Error(`Component "${componentId}" names a node in more than one scope of ${flowFilePath} (${scopes.join(", ")}). Node ids must be unique across the flow, top level and subflows.`);
+    }
+    if (scopes.length === 1) {
+      return { flowRead: true, found: true, suggestions: [] };
+    }
+    const nodes = allNodes(flow);
+    return {
+      flowRead: true,
+      found: false,
+      suggestions: suggestComponentIds(nodes, componentId)
+    };
   }
-  extract(flowContent, componentId) {
-    return extractNodeOutputSchema(flowContent, componentId, false);
+}
+function scopesOfNode(flow, componentId) {
+  const scopes = [];
+  const scan = (list, scope) => {
+    if (!Array.isArray(list))
+      return;
+    for (const n of list) {
+      if (isRecord(n) && n.id === componentId)
+        scopes.push(scope);
+    }
+  };
+  scan(flow.nodes, "nodes");
+  if (isRecord(flow.subflows)) {
+    for (const [key, sub] of Object.entries(flow.subflows)) {
+      if (isRecord(sub))
+        scan(sub.nodes, `subflows.${key}.nodes`);
+    }
   }
+  return scopes;
+}
+function allNodes(flow) {
+  const out = [];
+  const push = (list) => {
+    if (!Array.isArray(list))
+      return;
+    for (const n of list)
+      if (isRecord(n))
+        out.push(n);
+  };
+  push(flow.nodes);
+  if (isRecord(flow.subflows)) {
+    for (const sub of Object.values(flow.subflows)) {
+      if (isRecord(sub))
+        push(sub.nodes);
+    }
+  }
+  return out;
+}
+function squash(id) {
+  return id.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
+}
+function suggestComponentIds(nodes, componentId) {
+  const want = squash(componentId);
+  const hits = [];
+  for (const n of nodes) {
+    if (typeof n.id !== "string")
+      continue;
+    const display = isRecord(n.display) ? n.display : undefined;
+    const label = typeof display?.label === "string" ? display.label : "";
+    if (label === componentId || want !== "" && (squash(n.id) === want || squash(label) === want)) {
+      hits.push(n.id);
+    }
+  }
+  return [...new Set(hits)];
 }
 
 class SimulateFlowOutputSchemaReader extends FlowNodeOutputSchemaReader {
-  extract(flowContent, componentId) {
-    const result = extractNodeOutputSchema(flowContent, componentId, true);
+  extract(flow, componentId) {
+    const result = extractNodeOutputSchema(flow, 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);
+function extractNodeOutputSchema(flow, componentId, wrapAllOutputs) {
+  const node = allNodes(flow).find((n) => n.id === componentId);
   if (!node) {
     return { schema: undefined, nodeFound: false };
   }
@@ -286,7 +390,7 @@ class ChildSimulationSchemaReader {
     this.pathResolver = pathResolver;
   }
   async read(projectPath, parentComponentId, childComponentId) {
-    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const root = await this.pathResolver.resolveProjectPath(projectPath);
     const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
     if (flowError || !flowFilePath) {
       return {
@@ -383,7 +487,7 @@ class ChildSimulationSchemaReader {
         errorDetail: authError.message
       };
     }
-    const { FlowEvalRunApi } = await import("./flow-eval-run-api-zg951w2f.js");
+    const { FlowEvalRunApi } = await import("./flow-eval-run-api-3xt5n21a.js");
     const api = new FlowEvalRunApi;
     const [fetchError, components] = await catchError(api.getSimulatableComponents(config, processKey, processVersion));
     if (fetchError || !components) {
@@ -617,119 +721,6 @@ function findToolSchemaInResources(resources, childComponentId) {
   }
   return;
 }
-
-// ../flow-tool/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";
-}
-
 // ../flow-tool/src/services/flow-eval-input-schema.ts
 class FlowEvalInputSchema {
   fs;
@@ -739,7 +730,7 @@ class FlowEvalInputSchema {
     this.pathResolver = pathResolver;
   }
   async read(projectPath) {
-    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const root = await this.pathResolver.resolveProjectPath(projectPath);
     const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
     if (flowError || !flowFilePath) {
       return {
@@ -823,7 +814,7 @@ class FlowEvalSetCrud {
     return this.store.readJsonFiles(this.fs.path.join(root, "eval-sets"));
   }
   async add(projectPath, options) {
-    const resolvedProjectPath = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const resolvedProjectPath = await this.pathResolver.resolveProjectPath(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`;
@@ -903,251 +894,6 @@ class FlowEvalSetCrud {
     return true;
   }
 }
-
-// ../flow-tool/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);
-  }
-}
-
-// ../flow-tool/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);
-  }
-}
-
 // ../flow-tool/src/services/flow-eval-service.ts
 class FlowEvalService {
   fs;
@@ -1158,19 +904,21 @@ class FlowEvalService {
   inputSchema;
   outputSchema;
   nodeOutputSchema;
+  componentLocator;
   agentNodeSchema;
   childSimulationSchema;
   constructor(fs = getFileSystem()) {
     this.fs = fs;
-    const store = new FlowEvalFileStore(fs);
+    const store = new EvalFileStore(fs);
     const pathResolver = new FlowEvalPathResolver(fs);
-    this.evaluators = new FlowEvaluatorCrud(fs, store, pathResolver);
+    this.evaluators = new EvaluatorCrud(fs, store, pathResolver);
     this.evalSets = new FlowEvalSetCrud(fs, store, pathResolver);
-    this.evaluations = new FlowEvaluationCrud(fs, store, pathResolver);
-    this.files = new FlowEvalFiles(fs, pathResolver);
+    this.evaluations = new EvaluationCrud(fs, store, pathResolver);
+    this.files = new EvalFiles(fs, pathResolver);
     this.inputSchema = new FlowEvalInputSchema(fs, pathResolver);
     this.outputSchema = new FlowEvalOutputSchema(fs, pathResolver);
     this.nodeOutputSchema = new SimulateFlowOutputSchemaReader(fs, pathResolver);
+    this.componentLocator = new FlowComponentLocator(fs, pathResolver);
     this.agentNodeSchema = new FlowAgentNodeSchemaReader(fs, pathResolver);
     this.childSimulationSchema = new ChildSimulationSchemaReader(fs, pathResolver);
   }
@@ -1296,6 +1044,11 @@ class FlowEvalService {
     return this.evaluations.remove(projectPath, setIdOrName, evaluationIdOrName);
   }
   async addSimulation(projectPath, setIdOrName, evaluationIdOrName, simulation) {
+    const located = await this.componentLocator.find(projectPath, simulation.componentId);
+    if (located.flowRead && !located.found) {
+      const hint = located.suggestions.length ? ` Did you mean ${located.suggestions.map((id) => `"${id}"`).join(" or ")}? A simulation targets the node's id, not its label.` : " Use a node id from the .flow (nodes[].id or subflows.<id>.nodes[].id).";
+      throw new Error(`Component "${simulation.componentId}" not found in the flow.${hint}`);
+    }
     if (simulation.simulationStrategy === "Llm" && simulation.outputSchema === undefined) {
       const resolved = await this.nodeOutputSchema.read(projectPath, simulation.componentId);
       if (!resolved.nodeFound) {
@@ -1382,4 +1135,4 @@ export {
   FlowEvalService
 };
 
-//# debugId=7296CF04662698B464756E2164756E21
+//# debugId=3D01F72A484AF34964756E2164756E21