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

package/dist/{flow-eval-service-ededh59n.js → flow-eval-service-ma5psrsd.js}

@@ -4,51 +4,57 @@ import {
   findEvaluator,
   getLinkedEvaluators,
   removeEvaluatorRefFromSet
-} from "./packager-tool-12636p2y.js";
+} from "./packager-tool-mcjjj1hk.js";
 import {
   FlowAgentNodeSchemaReader,
   findFlowNode,
+  formatTriggerIdsHint,
   isDocumentEvalNode,
   isNodeEvalTarget,
+  listTriggerNodeIds,
   readNodeTargetId
-} from "./packager-tool-70eh7rpg.js";
+} from "./packager-tool-fm67whdy.js";
 import {
   buildDefaultCriteria,
   buildEvaluatorConfig,
+  evaluatorTypeAliases,
+  findMatchingDefinition,
   isRecord,
+  resolveEvalApiConfig,
+  resolveEvaluatorType,
   slugify
-} from "./packager-tool-ckhyvcn5.js";
-import {
-  evaluatorTypeAliases,
-  resolveEvaluatorType
-} from "./packager-tool-bftjhmqz.js";
+} from "./packager-tool-mfrdmqmt.js";
+import"./packager-tool-7msx23gd.js";
 import {
   FlowEvalFileStore
-} from "./packager-tool-rr8hveb9.js";
-import"./packager-tool-7309ymg1.js";
-import"./packager-tool-a6yfnjgx.js";
-import"./packager-tool-54b4v7wp.js";
-import"./packager-tool-29eg86w6.js";
+} from "./packager-tool-ygrrb1zh.js";
+import"./packager-tool-s1466723.js";
+import"./packager-tool-wynrdnqj.js";
+import"./packager-tool-te6rrpsz.js";
+import"./packager-tool-6rsegsby.js";
+import"./packager-tool-wd01egnx.js";
 import"./packager-tool-2513jrxr.js";
-import"./packager-tool-7rz102fw.js";
-import"./packager-tool-k4x5yn3p.js";
-import"./packager-tool-jjpc0yka.js";
+import"./packager-tool-khm7zsm8.js";
+import"./packager-tool-vcjq9xkc.js";
 import"./packager-tool-nkrmjr3a.js";
 import"./packager-tool-rs6jm14d.js";
 import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-ejyeka5x.js";
-import"./packager-tool-nxw5yzs7.js";
-import"./packager-tool-gbgfwx8f.js";
-import"./packager-tool-r87gxwqa.js";
+import"./packager-tool-7q6z6npd.js";
 import"./packager-tool-sc961w0q.js";
-import"./packager-tool-e8td7b01.js";
+import"./packager-tool-gpwec9sp.js";
+import"./packager-tool-vqcnvaae.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-d88rqwk8.js";
+import"./packager-tool-jysvpt8p.js";
+import"./packager-tool-fvm2dddf.js";
 import"./packager-tool-p79yh9ww.js";
+import"./packager-tool-vdc8r21p.js";
 import"./packager-tool-z83pga0z.js";
 import"./packager-tool-6ejqwbw9.js";
 import"./packager-tool-mcaf4ewf.js";
 import {
   catchError
-} from "./packager-tool-79gws1zn.js";
+} from "./packager-tool-z6nkdv48.js";
 import {
   getFileSystem
 } from "./packager-tool-0v3s8r01.js";
@@ -58,6 +64,206 @@ import {
   __require
 } from "./packager-tool-1yh8g550.js";
 
+// ../flow-tool/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 = extractConnectorOutputSchema(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 extractConnectorOutputSchema(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;
+}
+
 // ../flow-tool/src/services/flow-child-simulation-schema.ts
 var AGENT_TOOL_NODE_TYPE_PREFIX = "uipath.agent.resource.tool.";
 function nameMatchesId(name, id) {
@@ -78,21 +284,30 @@ class ChildSimulationSchemaReader {
     this.fs = fs;
     this.pathResolver = pathResolver;
   }
-  async read(projectPath, parentComponentId, childComponentId, authConfig) {
+  async read(projectPath, parentComponentId, childComponentId) {
     const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
     const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
     if (flowError || !flowFilePath) {
-      return { parentFound: false };
+      return {
+        parentFound: false,
+        reason: "Could not find a .flow file in the project."
+      };
     }
     const flowContent = String(await this.fs.readFile(flowFilePath, "utf-8"));
     let parsed;
     try {
       parsed = JSON.parse(flowContent);
     } catch {
-      return { parentFound: false };
+      return {
+        parentFound: false,
+        reason: "The .flow file contains invalid JSON."
+      };
     }
     if (!isRecord(parsed)) {
-      return { parentFound: false };
+      return {
+        parentFound: false,
+        reason: "The .flow file has an unexpected format."
+      };
     }
     const subflows = isRecord(parsed.subflows) ? Object.values(parsed.subflows) : [];
     const subflowNodes = subflows.flatMap((s) => isRecord(s) && Array.isArray(s.nodes) ? s.nodes : []);
@@ -117,44 +332,64 @@ class ChildSimulationSchemaReader {
       case "sameSolution":
         return this.resolveSameSolutionSchema(flowFilePath, agentKind.projectId, childComponentId);
       case "published":
-        return this.resolvePublishedAgentSchema(agentKind.processKey, agentKind.processVersion, childComponentId, authConfig);
+        return this.resolvePublishedAgentSchema(agentKind.processKey, agentKind.processVersion, childComponentId);
       case "unsupported":
-        return { parentFound: true };
+        return {
+          parentFound: true,
+          errorDetail: `Node "${parentComponentId}" is not an agent node.`
+        };
     }
   }
   async resolveSameSolutionSchema(flowFilePath, projectId, childComponentId) {
     if (/[/\\.]/.test(projectId)) {
-      return { parentFound: true };
+      return {
+        parentFound: true,
+        errorDetail: `Project id "${projectId}" contains path separators.`
+      };
     }
     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 };
+      return {
+        parentFound: true,
+        errorDetail: `Could not read agent.json for project "${projectId}": ${readError.message}`
+      };
     }
     let agent;
     try {
       agent = JSON.parse(String(raw));
     } catch {
-      return { parentFound: true };
+      return {
+        parentFound: true,
+        errorDetail: `agent.json for project "${projectId}" contains invalid JSON.`
+      };
     }
     if (!isRecord(agent)) {
-      return { parentFound: true };
+      return {
+        parentFound: true,
+        errorDetail: `agent.json for project "${projectId}" has an unexpected format.`
+      };
     }
     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;
+  async resolvePublishedAgentSchema(processKey, processVersion, childComponentId) {
+    const [authError, config] = await catchError(resolveEvalApiConfig());
+    if (authError) {
+      return {
+        parentFound: true,
+        errorDetail: authError.message
+      };
     }
-    const [fetchError, components] = await catchError(fetchSimulatableComponents(authConfig, processKey, processVersion));
+    const { FlowEvalRunApi } = await import("./flow-eval-run-api-hashjgq1.js");
+    const api = new FlowEvalRunApi;
+    const [fetchError, components] = await catchError(api.getSimulatableComponents(config, processKey, processVersion));
     if (fetchError || !components) {
-      return { parentFound: true };
+      return {
+        parentFound: true,
+        errorDetail: fetchError ? fetchError.message : "API returned no data."
+      };
     }
     const match = components.find((c) => c.id === childComponentId || nameMatchesId(c.name, childComponentId));
     if (!match?.outputSchema) {
@@ -163,50 +398,13 @@ class ChildSimulationSchemaReader {
     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."))
+  if (lower.startsWith(AGENT_TOOL_NODE_TYPE_PREFIX))
     return false;
-  return lower === "agent" || lower.startsWith("uipath.agent") || lower.startsWith("uipath.core.agent");
+  return lower === "agent" || lower.startsWith("uipath.agent.") || lower === "uipath.agent" || lower === "uipath.core.agent" || lower.startsWith("uipath.core.agent.");
 }
 function getAgentKind(node, definitions) {
   const nodeType = typeof node.type === "string" ? node.type : undefined;
@@ -220,14 +418,18 @@ function getAgentKind(node, definitions) {
   if (projectId) {
     return { kind: "sameSolution", projectId };
   }
-  if (nodeType?.startsWith("uipath.agent")) {
+  const lowerType = nodeType?.toLowerCase();
+  if (lowerType?.startsWith("uipath.agent.") || lowerType === "uipath.agent") {
     return { kind: "inlineCanvas" };
   }
-  if (nodeType?.startsWith("uipath.core.agent.")) {
-    const processKey = nodeType.split(".").at(-1) ?? "";
+  if (lowerType?.startsWith("uipath.core.agent.")) {
+    const defRecord = isRecord(definition) ? definition : undefined;
+    const defModel = isRecord(defRecord?.model) ? defRecord.model : undefined;
+    const defBindings = isRecord(defModel?.bindings) ? defModel.bindings : undefined;
+    const resourceKey = typeof defBindings?.resourceKey === "string" ? defBindings.resourceKey : undefined;
+    const processKey = resourceKey ?? 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 };
   }
@@ -257,7 +459,9 @@ 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);
+  const typeVersion = typeof node.typeVersion === "string" ? node.typeVersion : undefined;
+  const recordDefs = definitions.filter(isRecord);
+  return findMatchingDefinition(nodeType, typeVersion, recordDefs);
 }
 function resolveInlineCanvasSchema(parentComponentId, childComponentId, nodes, edges, definitions) {
   const childNodeIds = new Set;
@@ -272,6 +476,7 @@ function resolveInlineCanvasSchema(parentComponentId, childComponentId, nodes, e
       childNodeIds.add(target);
     }
   }
+  let childFound = false;
   for (const n of nodes) {
     if (!isRecord(n))
       continue;
@@ -280,12 +485,19 @@ function resolveInlineCanvasSchema(parentComponentId, childComponentId, nodes, e
     if (n.id !== childComponentId && !matchesComponentId(n, childComponentId)) {
       continue;
     }
+    childFound = true;
     const definition = findDefinitionForNode(n, definitions);
     const schema = extractToolOutputSchema(n, definition);
     if (schema) {
       return { parentFound: true, schema };
     }
   }
+  if (!childFound) {
+    return {
+      parentFound: true,
+      errorDetail: `No child component "${childComponentId}" is connected to "${parentComponentId}".`
+    };
+  }
   return { parentFound: true };
 }
 function matchesComponentId(node, componentId) {
@@ -310,14 +522,14 @@ function extractToolOutputSchema(node, definition) {
     if (output?.schema)
       return output.schema;
     if (Object.keys(outputs).length > 0) {
-      return { type: "object", properties: outputs };
+      return cleanOutputSchema({ 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);
+    const schema = extractConnectorOutputSchema2(inputs);
     if (schema)
       return schema;
   }
@@ -330,13 +542,16 @@ function extractToolOutputSchema(node, definition) {
       if (outputEntry)
         return outputEntry;
       if (Object.keys(outputDef).length > 0) {
-        return { type: "object", properties: outputDef };
+        return cleanOutputSchema({
+          type: "object",
+          properties: outputDef
+        });
       }
     }
   }
   return;
 }
-function extractConnectorOutputSchema(inputs) {
+function extractConnectorOutputSchema2(inputs) {
   if (!inputs)
     return;
   const detail = inputs.detail;
@@ -638,28 +853,41 @@ class FlowEvalSetCrud {
     return evalSet;
   }
   async resolveAgentNodeTarget(resolvedProjectPath, entryPoint) {
-    if (entryPoint === undefined || entryPoint.includes("/") || entryPoint.includes("#")) {
+    if (entryPoint === undefined) {
       return;
     }
-    const [findError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(resolvedProjectPath));
-    if (findError || !flowFilePath) {
-      return;
+    const flowContent = await this.readFlowContent(resolvedProjectPath);
+    if (entryPoint.includes("/") || entryPoint.includes("#")) {
+      throw new Error(`Entry point "${entryPoint}" looks like a BPMN path. The entry point is a trigger node id from the .flow file, not a path.${formatTriggerIdsHint(flowContent)} Omit --entry-point to use the flow's default trigger.`);
     }
-    const [readError, flowContent] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
-    if (readError) {
+    if (flowContent === undefined) {
       return;
     }
-    const lookup = findFlowNode(String(flowContent), entryPoint);
+    const lookup = findFlowNode(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.`);
+      throw new Error(`Entry point "${entryPoint}" does not match any node in the flow.${formatTriggerIdsHint(flowContent)} An agent node id creates a node-scoped eval set; omit --entry-point to use the flow's default trigger.`);
     }
     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;
+    if (isNodeEvalTarget(lookup.node)) {
+      return entryPoint;
+    }
+    if (!listTriggerNodeIds(flowContent).includes(entryPoint)) {
+      throw new Error(`Entry point "${entryPoint}" is not a trigger node.${formatTriggerIdsHint(flowContent)} An agent node id creates a node-scoped eval set; omit --entry-point to use the flow's default trigger.`);
+    }
+    return;
+  }
+  async readFlowContent(resolvedProjectPath) {
+    const [findError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(resolvedProjectPath));
+    if (findError || !flowFilePath) {
+      return;
+    }
+    const [readError, flowContent] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    return readError ? undefined : String(flowContent);
   }
   async remove(projectPath, idOrName) {
     const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
@@ -919,206 +1147,6 @@ class FlowEvaluatorCrud {
   }
 }
 
-// ../flow-tool/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;
-}
-
 // ../flow-tool/src/services/flow-eval-service.ts
 class FlowEvalService {
   fs;
@@ -1273,7 +1301,7 @@ class FlowEvalService {
         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.`);
+        throw new Error(`Could not auto-resolve output schema for component "${simulation.componentId}". ` + `The node has no declared outputs.`);
       }
       simulation = { ...simulation, outputSchema: resolved.schema };
     }
@@ -1286,6 +1314,7 @@ class FlowEvalService {
     return this.evaluations.removeSimulation(projectPath, setIdOrName, evaluationIdOrName, componentId);
   }
   async addChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childSimulation) {
+    let warning;
     if (childSimulation.outputSchema === undefined) {
       const resolved = await this.childSimulationSchema.read(projectPath, parentComponentId, childSimulation.componentId);
       if (resolved.schema) {
@@ -1295,15 +1324,27 @@ class FlowEvalService {
         };
       } else if (childSimulation.simulationStrategy === "Llm") {
         if (!resolved.parentFound) {
-          throw new Error(`Parent agent "${parentComponentId}" not found in the flow. Verify the parent component ID.`);
+          const detail = resolved.reason ? ` ${resolved.reason}` : "";
+          throw new Error(`Parent agent "${parentComponentId}" not found in the flow.${detail} Verify the parent component ID.`);
+        }
+        if (resolved.errorDetail) {
+          throw new Error(`Could not auto-resolve output schema for "${childSimulation.componentId}" inside agent "${parentComponentId}": ${resolved.errorDetail}`);
+        }
+        throw new Error(`Could not auto-resolve output schema for "${childSimulation.componentId}" inside agent "${parentComponentId}". ` + `The tool has no declared outputs.`);
+      } else if (childSimulation.simulationStrategy === "Static") {
+        if (!resolved.parentFound) {
+          const detail = resolved.reason ? ` ${resolved.reason}` : "";
+          warning = `Parent agent "${parentComponentId}" not found in the flow.${detail} Mock value key validation was skipped.`;
+        } else if (resolved.errorDetail) {
+          warning = `Could not resolve output schema for "${childSimulation.componentId}": ${resolved.errorDetail}. ` + `Mock value key validation was skipped.`;
         }
-        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);
+    const simulation = await this.evaluations.addChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childSimulation);
+    return { simulation, warning };
   }
   async listChildSimulations(projectPath, setIdOrName, evaluationIdOrName, parentComponentId) {
     const evalSet = await this.evaluations.list(projectPath, setIdOrName);
@@ -1323,6 +1364,9 @@ class FlowEvalService {
 function validateMockValueKeys(mockValue, outputSchema, componentId) {
   if (!isRecord(mockValue) || !isRecord(outputSchema))
     return;
+  if (outputSchema.additionalProperties === true || typeof outputSchema.additionalProperties === "object" && outputSchema.additionalProperties !== null) {
+    return;
+  }
   const properties = isRecord(outputSchema.properties) ? outputSchema.properties : undefined;
   if (!properties)
     return;
@@ -1337,4 +1381,4 @@ export {
   FlowEvalService
 };
 
-//# debugId=6928994CD8DB4F7364756E2164756E21
+//# debugId=FA484EAB0699281A64756E2164756E21