@uipath/flow-tool 1.201.0-preview.131 → 1.201.0-preview.133

package/dist/{packager-tool-s5y06ny4.js → packager-tool-2xgc101h.js}

@@ -9,18 +9,18 @@ import {
   readFlowWorkflow,
   validateIntSvcNode,
   writeFlowWorkflow
-} from "./packager-tool-v61wap3v.js";
+} from "./packager-tool-djagtpkt.js";
 import {
   findNearestParentUipxFile,
   getLoginStatusAsync,
   readSolutionManifest
-} from "./packager-tool-b0s5d4ek.js";
+} from "./packager-tool-0sz8se22.js";
 import {
   OutputFormatter,
   RESULTS,
   catchError,
   logger
-} from "./packager-tool-ny53xmsd.js";
+} from "./packager-tool-cvwr40ax.js";
 import {
   getFileSystem
 } from "./packager-tool-1cb0d5e0.js";
@@ -32,14 +32,18 @@ import {
   createFlowRefResolver,
   generateNodeIdAndName,
   getMigrationChain,
+  isInlineAgentNodeType,
   migrateWorkflowToFloor,
   minimumSupportedVersion,
+  operateRuntimeOptions,
+  readInlineAgentSource,
   registerFlowMigrationsI18n,
   resolveWorkflowRefs,
   runtimeMigrations,
   runtimeVersion
-} from "./packager-tool-mt2g0zjx.js";
+} from "./packager-tool-gasyxww9.js";
 import {
+  AGENT_NODE_TYPES,
   EntryPointType,
   ProjectType,
   cliRules,
@@ -53,13 +57,15 @@ import {
   getJsExpressionBody,
   instance,
   isBlockingSeverity,
+  isConversationalOrVoiceAgentNodeType,
   isExpressionValue,
   isStartEventNode,
+  isVoiceAgentNodeType,
   mergeBindingResources,
   parseWorkflowJson,
   registerFlowSchemaI18n,
   runRules
-} from "./packager-tool-952kqpax.js";
+} from "./packager-tool-78a3szsp.js";
 
 // src/services/connector-node-types.ts
 function isConnectorTriggerType(nodeType) {
@@ -6543,6 +6549,451 @@ function validateConnectorBindings(workflow, catalog, options = {}) {
   return issues;
 }
 
+// src/services/flow-eval-schema/prompts.ts
+var DEFAULT_EVALUATOR_PROMPT = `As an expert evaluator, analyze the semantic similarity of these JSON contents to determine a score from 0-100. Focus on comparing the meaning and contextual equivalence of corresponding fields, accounting for alternative valid expressions, synonyms, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
+----
+ExpectedOutput:
+{{ExpectedOutput}}
+----
+ActualOutput:
+{{ActualOutput}}
+`;
+var DEFAULT_TRAJECTORY_EVALUATOR_PROMPT = `As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
+----
+UserOrSyntheticInputGivenToAgent:
+{{UserOrSyntheticInput}}
+----
+SimulationInstructions:
+{{SimulationInstructions}}
+----
+ExpectedAgentBehavior:
+{{ExpectedAgentBehavior}}
+----
+AgentRunHistory:
+{{AgentRunHistory}}
+`;
+
+// src/services/flow-eval-schema/evaluator-fields.ts
+var targetOutputKeyConfigField = {
+  key: "targetOutputKey",
+  label: "Target Output Key",
+  type: "targetOutputKey",
+  required: false,
+  description: "The key in the output to evaluate"
+};
+var caseSensitiveConfigField = {
+  key: "caseSensitive",
+  label: "Case Sensitive",
+  type: "boolean",
+  required: false,
+  default: false,
+  description: "If true, the comparison is case-sensitive"
+};
+var negatedConfigField = {
+  key: "negated",
+  label: "Negated",
+  type: "boolean",
+  required: false,
+  default: false,
+  description: "If true, the evaluation passes when the match is not found"
+};
+var expectedOutputCriteriaField = {
+  key: "expectedOutput",
+  label: "Expected Output",
+  type: "object",
+  required: false,
+  description: "The expected output value for this evaluator"
+};
+var llmBaseConfigFields = [
+  {
+    key: "model",
+    label: "Model",
+    type: "llmModel",
+    required: true,
+    description: "The LLM model to use for judging"
+  },
+  {
+    key: "prompt",
+    label: "Evaluation Prompt",
+    type: "string",
+    required: true,
+    default: DEFAULT_EVALUATOR_PROMPT,
+    description: "Custom prompt template for the LLM judge"
+  },
+  {
+    key: "temperature",
+    label: "Temperature",
+    type: "number",
+    required: true,
+    default: 0,
+    min: 0,
+    max: 2,
+    step: 0.1,
+    description: "Temperature for LLM generation"
+  },
+  {
+    key: "maxTokens",
+    label: "Max Tokens",
+    type: "number",
+    required: true,
+    default: 8192,
+    min: 0,
+    max: 16384,
+    step: 256,
+    description: "Maximum tokens for LLM response"
+  }
+];
+var llmTrajectoryBaseConfigFields = llmBaseConfigFields.map((field) => field.key === "prompt" ? { ...field, default: DEFAULT_TRAJECTORY_EVALUATOR_PROMPT } : field);
+
+// src/services/flow-eval-schema/deterministic-evaluators.ts
+var DETERMINISTIC_EVALUATOR_TYPES = {
+  "uipath-contains": {
+    name: "Contains Text",
+    description: "Check if output contains specific text",
+    category: "deterministic",
+    shortDescription: "Passes when output contains given text",
+    configFields: [
+      targetOutputKeyConfigField,
+      caseSensitiveConfigField,
+      {
+        ...negatedConfigField,
+        label: "Negated (should NOT contain)"
+      }
+    ],
+    criteriaFields: [
+      {
+        key: "searchText",
+        label: "Search Text",
+        type: "string",
+        required: false,
+        minLength: 1,
+        description: "The text to search for in the output"
+      }
+    ],
+    examples: {
+      criteria: { searchText: "loan approved" }
+    }
+  },
+  "uipath-exact-match": {
+    name: "Exact Match",
+    description: "Check if output exactly matches expected value",
+    category: "deterministic",
+    shortDescription: "Passes when output is an exact match",
+    configFields: [
+      targetOutputKeyConfigField,
+      caseSensitiveConfigField,
+      negatedConfigField
+    ],
+    criteriaFields: [expectedOutputCriteriaField],
+    examples: {
+      criteria: { expectedOutput: { value: "Application approved" } }
+    }
+  },
+  "uipath-json-similarity": {
+    name: "JSON Similarity",
+    description: "Compare JSON output similarity",
+    category: "deterministic",
+    shortDescription: "Passes when JSON structures are similar",
+    configFields: [targetOutputKeyConfigField],
+    criteriaFields: [expectedOutputCriteriaField],
+    examples: {
+      criteria: { expectedOutput: { status: "ok" } }
+    }
+  }
+};
+
+// src/services/flow-eval-schema/llm-judge-evaluators.ts
+var LLM_JUDGE_EVALUATOR_TYPES = {
+  "uipath-llm-judge-output-semantic-similarity": {
+    name: "LLM Judge Output",
+    description: "Use LLM to judge semantic similarity of outputs",
+    category: "llm-judge",
+    shortDescription: "AI judges if output semantically matches expected",
+    configFields: [...llmBaseConfigFields, targetOutputKeyConfigField],
+    criteriaFields: [expectedOutputCriteriaField],
+    examples: {
+      config: { model: "gpt-4o", temperature: 0 },
+      criteria: {
+        expectedOutput: {
+          text: "The loan has been approved for the requested amount."
+        }
+      }
+    }
+  },
+  "uipath-llm-judge-output-strict-json-similarity": {
+    name: "LLM Judge Strict JSON",
+    description: "Use LLM to judge strict JSON similarity",
+    category: "llm-judge",
+    shortDescription: "AI judges strict JSON structural match",
+    configFields: [...llmBaseConfigFields, targetOutputKeyConfigField],
+    criteriaFields: [expectedOutputCriteriaField],
+    examples: {
+      config: { model: "gpt-4o", temperature: 0 },
+      criteria: { expectedOutput: { result: "success" } }
+    }
+  },
+  "uipath-llm-judge-trajectory-similarity": {
+    name: "LLM Judge Trajectory",
+    description: "Use LLM to judge agent trajectory and behavior",
+    category: "llm-judge",
+    shortDescription: "AI judges if agent followed expected behavior",
+    configFields: llmTrajectoryBaseConfigFields,
+    criteriaFields: [
+      {
+        key: "expectedAgentBehavior",
+        label: "Expected Agent Behavior",
+        type: "string",
+        required: false,
+        description: "Description of expected agent behavior and actions"
+      }
+    ],
+    examples: {
+      config: { model: "gpt-4o" },
+      criteria: {
+        expectedAgentBehavior: "Agent checks eligibility, then calls approval API"
+      }
+    }
+  },
+  "uipath-llm-judge-trajectory-simulation": {
+    name: "LLM Judge Simulation",
+    description: "Use LLM to judge simulation trajectory",
+    category: "llm-judge",
+    shortDescription: "AI judges simulated agent execution path",
+    configFields: llmTrajectoryBaseConfigFields,
+    criteriaFields: [
+      {
+        key: "expectedAgentBehavior",
+        label: "Expected Agent Behavior",
+        type: "string",
+        required: false,
+        description: "Description of expected agent behavior during simulation"
+      }
+    ],
+    examples: {
+      config: { model: "gpt-4o" },
+      criteria: {
+        expectedAgentBehavior: "Agent simulates the user journey through checkout flow"
+      }
+    }
+  }
+};
+
+// src/services/flow-eval-schema/tool-call-evaluators.ts
+var TOOL_CALL_EVALUATOR_TYPES = {
+  "uipath-tool-call-args": {
+    name: "Tool Call Arguments",
+    description: "Verify tool call arguments match expected values",
+    category: "tool-call",
+    shortDescription: "Checks that tools were called with correct arguments",
+    configFields: [
+      {
+        key: "strict",
+        label: "Strict Mode",
+        type: "boolean",
+        required: false,
+        default: false,
+        description: "If true, requires exact match of all tool call arguments"
+      },
+      {
+        key: "subset",
+        label: "Subset Mode",
+        type: "boolean",
+        required: false,
+        default: false,
+        description: "If true, allows actual tool calls to be a subset of expected"
+      }
+    ],
+    criteriaFields: [
+      {
+        key: "toolCalls",
+        label: "Tool Calls",
+        type: "toolCallArgs",
+        required: false,
+        description: "Expected tool calls with names and arguments"
+      }
+    ]
+  },
+  "uipath-tool-call-count": {
+    name: "Tool Call Count",
+    description: "Verify tool call counts match expected values",
+    category: "tool-call",
+    shortDescription: "Checks number of times each tool was called",
+    configFields: [
+      {
+        key: "strict",
+        label: "Strict Mode",
+        type: "boolean",
+        required: false,
+        default: false,
+        description: "If true, requires exact count match"
+      }
+    ],
+    criteriaFields: [
+      {
+        key: "toolCallsCount",
+        label: "Tool Calls Count",
+        type: "toolCallCount",
+        required: false,
+        description: "Expected tool call counts with comparison operators"
+      }
+    ]
+  },
+  "uipath-tool-call-order": {
+    name: "Tool Call Order",
+    description: "Verify tool calls occur in expected order",
+    category: "tool-call",
+    shortDescription: "Checks that tools were called in the right sequence",
+    configFields: [
+      {
+        key: "strict",
+        label: "Strict Mode",
+        type: "boolean",
+        required: false,
+        default: false,
+        description: "If true, requires exact order match"
+      }
+    ],
+    criteriaFields: [
+      {
+        key: "toolCallsOrder",
+        label: "Tool Calls Order",
+        type: "toolCallOrder",
+        required: false,
+        description: "Tool names in expected execution order"
+      }
+    ]
+  },
+  "uipath-tool-call-output": {
+    name: "Tool Call Output",
+    description: "Verify tool call outputs match expected values",
+    category: "tool-call",
+    shortDescription: "Checks that tool outputs match expected values",
+    configFields: [
+      {
+        key: "strict",
+        label: "Strict Mode",
+        type: "boolean",
+        required: false,
+        default: false,
+        description: "If true, requires exact output match"
+      }
+    ],
+    criteriaFields: [
+      {
+        key: "toolOutputs",
+        label: "Tool Outputs",
+        type: "toolCallOutput",
+        required: false,
+        description: "Expected tool outputs with names and output values"
+      }
+    ]
+  }
+};
+
+// src/services/flow-eval-schema/registry.ts
+var EVALUATOR_TYPE_REGISTRY = {
+  ...DETERMINISTIC_EVALUATOR_TYPES,
+  ...LLM_JUDGE_EVALUATOR_TYPES,
+  ...TOOL_CALL_EVALUATOR_TYPES
+};
+var EVALUATOR_TYPE_ALIASES = {
+  "exact-match": "uipath-exact-match",
+  "json-similarity": "uipath-json-similarity",
+  contains: "uipath-contains",
+  "llm-judge-output": "uipath-llm-judge-output-semantic-similarity",
+  "llm-judge-strict-json": "uipath-llm-judge-output-strict-json-similarity",
+  "llm-judge-trajectory": "uipath-llm-judge-trajectory-similarity",
+  "llm-judge-trajectory-simulation": "uipath-llm-judge-trajectory-simulation"
+};
+
+// src/services/flow-eval-schema/helpers.ts
+function evaluatorTypeAliases() {
+  return Object.keys(EVALUATOR_TYPE_ALIASES);
+}
+function isEvaluatorTypeId(value) {
+  return value in EVALUATOR_TYPE_REGISTRY;
+}
+function getEvaluatorTypeDefinition(typeId) {
+  if (!isEvaluatorTypeId(typeId)) {
+    return null;
+  }
+  return EVALUATOR_TYPE_REGISTRY[typeId];
+}
+function resolveEvaluatorType(type) {
+  const resolved = EVALUATOR_TYPE_ALIASES[type] ?? type;
+  if (!isEvaluatorTypeId(resolved)) {
+    throw new Error(`Unknown evaluator type "${type}". Valid types: ${evaluatorTypeAliases().join(", ")}`);
+  }
+  return resolved;
+}
+function getDefaultConfigForEvaluatorType(typeId) {
+  return collectFieldDefaults(EVALUATOR_TYPE_REGISTRY[typeId].configFields);
+}
+function collectFieldDefaults(fields) {
+  const defaults = {};
+  for (const field of fields) {
+    if (field.default !== undefined) {
+      defaults[field.key] = field.default;
+    }
+  }
+  return defaults;
+}
+function evaluatorTypeHasConfigField(typeId, fieldKey) {
+  return getEvaluatorTypeDefinition(typeId)?.configFields.some((field) => field.key === fieldKey) ?? false;
+}
+function evaluatorCanUseSharedExpectedOutput(typeId) {
+  return getEvaluatorTypeDefinition(typeId)?.criteriaFields.some((field) => field.key === "expectedOutput" && field.type === "object") ?? false;
+}
+// src/services/flow-eval-utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+  return UUID_RE.test(value);
+}
+function stripJsonExt(name) {
+  return name.endsWith(".json") ? name.slice(0, -".json".length) : name;
+}
+function slugify(text) {
+  const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return slug || "untitled";
+}
+function getEvaluatorRef(evaluator) {
+  return stripJsonExt(evaluator.fileName ?? `${evaluator.id}.json`);
+}
+function buildEvaluatorConfig(typeId, options) {
+  const evaluatorConfig = {
+    name: options.name,
+    ...getDefaultConfigForEvaluatorType(typeId)
+  };
+  if (evaluatorTypeHasConfigField(typeId, "targetOutputKey")) {
+    evaluatorConfig.targetOutputKey = options.targetOutputKey ?? "*";
+  }
+  if (options.model !== undefined) {
+    evaluatorConfig.model = options.model;
+  }
+  if (options.prompt !== undefined) {
+    evaluatorConfig.prompt = options.prompt;
+  }
+  return evaluatorConfig;
+}
+function buildDefaultCriteria(evaluators, expectedOutput, searchText) {
+  const criterias = {};
+  for (const evaluator of evaluators) {
+    const key = evaluator.id;
+    if (expectedOutput !== undefined && evaluatorCanUseSharedExpectedOutput(evaluator.evaluatorTypeId)) {
+      criterias[key] = { expectedOutput };
+    } else if (searchText !== undefined && evaluator.evaluatorTypeId === "uipath-contains") {
+      criterias[key] = { searchText };
+    } else {
+      const defaultCriteria = evaluator.evaluatorConfig.defaultEvaluationCriteria;
+      criterias[key] = isRecord(defaultCriteria) ? defaultCriteria : null;
+    }
+  }
+  return criterias;
+}
+
 // src/services/flow-migration-check.ts
 if (!instance.isInitialized) {
   instance.init({
@@ -6665,32 +7116,6 @@ class FlowEvalFileStore {
 }
 
 // src/services/packaging-utils.ts
-var AUTONOMOUS_AGENT_NODE_TYPE = "uipath.agent.autonomous";
-var CONVERSATIONAL_AGENT_NODE_TYPE = "uipath.agent.conversational";
-var INLINE_AGENT_TYPES = [
-  AUTONOMOUS_AGENT_NODE_TYPE,
-  CONVERSATIONAL_AGENT_NODE_TYPE
-];
-function readInlineAgentSource(node) {
-  const candidates = [
-    node.inputs?.source,
-    node.model?.source,
-    node.inputs?.agentProjectId,
-    node.model?.agentProjectId
-  ];
-  for (const candidate of candidates) {
-    if (typeof candidate === "string" && candidate.length > 0) {
-      return candidate;
-    }
-  }
-  return;
-}
-function isInlineAgentNodeType(type) {
-  return typeof type === "string" && INLINE_AGENT_TYPES.includes(type);
-}
-function isConversationalAgentNodeType(type) {
-  return type === CONVERSATIONAL_AGENT_NODE_TYPE;
-}
 function fileNodesToPackagingNodes(nodes) {
   return nodes.map((node) => ({
     id: node.id,
@@ -6702,17 +7127,17 @@ function fileNodesToPackagingNodes(nodes) {
     ...node.model ? { model: node.model } : {}
   }));
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toResourceList(value) {
   if (!Array.isArray(value))
     return;
-  const resources = value.filter(isRecord);
+  const resources = value.filter(isRecord2);
   return resources.length === value.length ? resources : undefined;
 }
 function normalizePackagingBindingsJson(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return;
   const resources = toResourceList(value.resources);
   if (!resources)
@@ -6846,7 +7271,7 @@ function buildInlineAgentDescriptors(nodes) {
     out.push({
       name: label,
       agentProjectId: source,
-      isConversational: isConversationalAgentNodeType(node.type),
+      isConversational: isConversationalOrVoiceAgentNodeType(node.type),
       entryPointPath: `${source}/agent.json`
     });
   }
@@ -6873,7 +7298,8 @@ async function writePackagingArtifactsDetailed(fs, projectDir, projectId, packag
   await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(stagedBindingsJson, null, 2)}
 `);
   const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
-  await fs.writeFile(fs.path.join(projectDir, "operate.json"), `${JSON.stringify(generateOperateJson(projectId, mainEntryPoint), null, 2)}
+  const operateJson = generateOperateJson(projectId, mainEntryPoint, operateRuntimeOptions(packagingNodes));
+  await fs.writeFile(fs.path.join(projectDir, "operate.json"), `${JSON.stringify(operateJson, null, 2)}
 `);
   const packageDescriptorJson = options.packageDescriptorJson ?? {
     $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
@@ -7173,6 +7599,12 @@ var addNodeToFlow = async (filePath, nodeType, options = {}) => {
   const { id, displayName } = generateNodeIdAndName(options.label ?? manifest.display.label, existingIds);
   const bindingsBefore = workflow.bindings?.length ?? 0;
   const node = addNode(workflow, manifest, id, options.position ?? { x: 0, y: 0 }, options.label ?? displayName);
+  const schema = manifest.inputDefinition;
+  if (manifest.inputDefaults === undefined && schema?.type === "object") {
+    for (const schemaKey of Object.keys(schema)) {
+      delete node.inputs[schemaKey];
+    }
+  }
   let bindingsCreated = 0;
   if (isProcessNode(manifest)) {
     const { nameBinding, folderBinding } = createProcessBindings(manifest);
@@ -7353,10 +7785,6 @@ if (!instance.isInitialized) {
   });
 }
 registerFlowSchemaI18n(instance);
-var AGENT_NODE_TYPES = [
-  "uipath.agent.autonomous",
-  "uipath.agent.conversational"
-];
 function extractPromptVariables(content) {
   const vars = new Set;
   const re = /\{\{([^}]*)\}\}/g;
@@ -7746,6 +8174,7 @@ Validating: ${absolutePath}
     issues.push(...this.validateAgentInputBindings(workflow, hydrationDiagnoses, ""));
     issues.push(...this.validateAgentPromptInputRefs(workflow, hydrationDiagnoses, ""));
     issues.push(...this.validateAgentInputScopeRefs(workflow, hydrationDiagnoses, ""));
+    issues.push(...this.validateVoiceAgentSettings(workflow, hydrationDiagnoses, ""));
     issues.push(...await this.validateSolutionRegistrationAndLayout(absolutePath));
     const subflows = workflow.subflows ?? {};
     for (const [subflowId, entry] of Object.entries(subflows)) {
@@ -7767,6 +8196,7 @@ Validating: ${absolutePath}
       issues.push(...this.validateAgentInputBindings(subGraph, hydrationDiagnoses, prefix));
       issues.push(...this.validateAgentPromptInputRefs(subGraph, hydrationDiagnoses, prefix));
       issues.push(...this.validateAgentInputScopeRefs(subGraph, hydrationDiagnoses, prefix));
+      issues.push(...this.rejectSubflowVoiceAgents(subGraph, prefix));
     }
     this.enrichInlineAgentPromptIssues(issues, hydrationDiagnoses, flowDir);
     return {
@@ -7852,11 +8282,24 @@ Validating: ${absolutePath}
       if (!diag.agentJsonExists)
         continue;
       const [readErr, raw] = await catchError(this.fs.readFile(agentJsonPath, "utf-8"));
-      if (readErr || !raw)
+      if (readErr || !raw) {
+        diag.agentJsonUnparseable = true;
         continue;
+      }
       const [parseErr, agent] = await catchError(Promise.resolve(raw).then((s) => JSON.parse(s)));
-      if (parseErr || !agent)
+      if (parseErr || !agent) {
+        diag.agentJsonUnparseable = true;
         continue;
+      }
+      const settings = agent.settings;
+      if (isVoiceAgentNodeType(node.type)) {
+        const voiceSettings = isRecord(settings) ? settings.voice : undefined;
+        diag.voiceSettingsPresent = isRecord(voiceSettings);
+        if (diag.voiceSettingsPresent && inputs.voice === undefined) {
+          inputs.voice = voiceSettings;
+        }
+        diag.isConversationalAgent = isRecord(agent.metadata) && agent.metadata.isConversational === true;
+      }
       const messages = agent.messages;
       if (!Array.isArray(messages))
         continue;
@@ -7892,7 +8335,6 @@ Validating: ${absolutePath}
       if (Object.keys(byField).length > 0) {
         diag.promptVariablesByField = byField;
       }
-      const settings = agent.settings;
       if (settings && typeof settings === "object") {
         const s = settings;
         if (typeof s.temperature === "number" && inputs.temperature === undefined) {
@@ -7962,6 +8404,63 @@ Validating: ${absolutePath}
     }
     return issues;
   }
+  rejectSubflowVoiceAgents(graph, pathPrefix) {
+    const issues = [];
+    for (const node of graph.nodes) {
+      if (!isVoiceAgentNodeType(node.type))
+        continue;
+      const label = node.display?.label ?? node.id;
+      issues.push({
+        path: `${pathPrefix}nodes[${node.id}]`,
+        message: `Voice agent "${label}": voice agent nodes are not supported inside subflows — move it to the top-level flow.`,
+        severity: "error"
+      });
+    }
+    return issues;
+  }
+  validateVoiceAgentSettings(graph, diagnoses, pathPrefix) {
+    const issues = [];
+    for (const node of graph.nodes) {
+      if (!isVoiceAgentNodeType(node.type))
+        continue;
+      const diag = diagnoses.get(node.id);
+      if (!diag || diag.sourceLocation === "missing")
+        continue;
+      const label = node.display?.label ?? node.id;
+      const agentJsonPath = diag.agentJsonPath ?? `${diag.sourceId}/agent.json`;
+      if (!diag.agentJsonExists) {
+        issues.push({
+          path: `${pathPrefix}nodes[${node.id}].inputs.source`,
+          message: `Voice agent "${label}": agent.json not found at \`${agentJsonPath}\`. A voice agent node needs its backing agent directory inside the flow project — create it with \`uip agent init "<flowDir>" --inline-in-flow --conversational\` (then add \`settings.voice\` to its agent.json) or fix \`inputs.source\`.`,
+          severity: "error"
+        });
+        continue;
+      }
+      if (diag.agentJsonUnparseable) {
+        issues.push({
+          path: `${pathPrefix}nodes[${node.id}].inputs.source`,
+          message: `Voice agent "${label}": \`${agentJsonPath}\` exists but is empty or not valid JSON. Fix the file — check for merge-conflict markers or a truncated write.`,
+          severity: "error"
+        });
+        continue;
+      }
+      if (diag.voiceSettingsPresent === false) {
+        issues.push({
+          path: `${pathPrefix}nodes[${node.id}].inputs.source`,
+          message: `Voice agent "${label}": \`${agentJsonPath}\` has no \`settings.voice\`. Add the voice settings object (model, maxTokens, temperature, persona).`,
+          severity: "error"
+        });
+      }
+      if (diag.isConversationalAgent === false) {
+        issues.push({
+          path: `${pathPrefix}nodes[${node.id}].inputs.source`,
+          message: `Voice agent "${label}": \`${agentJsonPath}\` is not a conversational agent. Voice agents run on the conversational engine — set \`metadata.isConversational: true\` and \`settings.engine: "conversational-v1"\`.`,
+          severity: "error"
+        });
+      }
+    }
+    return issues;
+  }
   buildPromptInputRefIssues(node, field, vars, declared, label, pathPrefix) {
     const issues = [];
     const malformed = [];
@@ -8798,6 +9297,6 @@ Validating: ${absolutePath}
   }
 }
 
-export { ensureDirectory, FlowEvalFileStore, readInlineAgentSource, isInlineAgentNodeType, fileNodesToPackagingNodes, packageInlineAgents, stageInlineAgentPackageFiles, buildInlineAgentDescriptors, writePackagingArtifacts, writePackagingArtifactsDetailed, regenerateBindingsFile, NodeTypeNotFoundError, NodeTypeNotEnabledError, SourceRequiredError, listNodesInFlow, ensureProcessBindings, collectNodeBindingResourceKeys, addNodeToFlow, deleteNodeFromFlow, ERROR_SOURCE_PORT, enableErrorHandlingForErrorEdges, expandHandleIds, portMatchesTemplate, captureMigrationIssues, formatMigrationFailureMessage, isConnectorTriggerType, isConnectorWaitForEventType, isEventDrivenConnectorType, scanDetailForCrossNodeBindings, connectorNodeValidator, FlowValidateService };
+export { ensureDirectory, FlowEvalFileStore, fileNodesToPackagingNodes, packageInlineAgents, stageInlineAgentPackageFiles, buildInlineAgentDescriptors, writePackagingArtifacts, writePackagingArtifactsDetailed, regenerateBindingsFile, NodeTypeNotFoundError, NodeTypeNotEnabledError, SourceRequiredError, listNodesInFlow, ensureProcessBindings, collectNodeBindingResourceKeys, addNodeToFlow, deleteNodeFromFlow, ERROR_SOURCE_PORT, enableErrorHandlingForErrorEdges, expandHandleIds, portMatchesTemplate, evaluatorTypeAliases, resolveEvaluatorType, isRecord, isUUID, stripJsonExt, slugify, getEvaluatorRef, buildEvaluatorConfig, buildDefaultCriteria, captureMigrationIssues, formatMigrationFailureMessage, isConnectorTriggerType, isConnectorWaitForEventType, isEventDrivenConnectorType, scanDetailForCrossNodeBindings, connectorNodeValidator, FlowValidateService };
 
-//# debugId=4018E76FF70902A364756E2164756E21
+//# debugId=9B1959973F3B05AD64756E2164756E21