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

package/dist/agents.d.ts

@@ -16,4 +16,9 @@ export declare function buildInlineAgentContract(config: {
     projectPath: string;
     outputPath: string;
 }): Promise<InlineAgentContract>;
-export declare const processAgents: (fileSystem: IFileSystem, logger: IToolLogger, projectPath: string, contentFolder: string) => Promise<void>;
+/**
+ * Build every root-level agent directory into the content folder and merge
+ * their binding resources. Returns each built agent.json keyed by its
+ * directory name (the source UUID).
+ */
+export declare const processAgents: (fileSystem: IFileSystem, logger: IToolLogger, projectPath: string, contentFolder: string) => Promise<Map<string, Record<string, unknown>>>;

package/dist/flow-tool.d.ts

@@ -28,6 +28,17 @@ export declare class FlowTool extends ProjectTool {
      * of any stale artifacts that may exist on disk.
      */
     private generateFlowPackagingArtifacts;
+    /**
+     * `builtAgents` plus, for each voice node whose agent was not built, the
+     * agent.json copied into the content folder. Voice nodes embed the
+     * definition into the BPMN, so — unlike text agents — a source missing
+     * from the map fails the whole build, not just an entry point.
+     * A source with no copied agent.json stays absent;
+     * `buildVoiceAgentDefinitions` reports it.
+     */
+    private resolveVoiceAgents;
+    /** Read an `agent.json` copied in without going through `buildAgent`. */
+    private readCopiedAgentJson;
     /**
      * Copy project files into the correct nupkg structure.
      *

package/dist/index.d.ts

@@ -3,4 +3,6 @@ export { replaceExporterVersion } from "./exporter-version.js";
 export { createFlowRefResolver, type FlowIoLogger, migrateRawWorkflow, readFlowWorkflow, resolveAndMigrateWorkflow, resolveWorkflowRefs, } from "./flow-io.js";
 export { FlowTool } from "./flow-tool.js";
 export { FlowToolFactory } from "./flow-tool-factory.js";
-export { setPublishIntentOnInlineAgents } from "./inline-agent-utils.js";
+export { isInlineAgentNodeType, readInlineAgentSource, setPublishIntentOnInlineAgents, } from "./inline-agent-utils.js";
+export { operateRuntimeOptions } from "./operate-runtime-options.js";
+export { assertVoiceAgentDefinitionsEmbedded, type VoiceAgentFlowNode, voiceConvertOptions, } from "./voice-agent-definitions.js";

package/dist/index.js

@@ -32,7 +32,7 @@ import {
 // package.json
 var package_default = {
   name: "@uipath/packager-tool-flow",
-  version: "1.201.0-preview.131",
+  version: "1.201.0-preview.133",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -75,17 +75,17 @@ var package_default = {
   license: "ISC",
   peerDependencies: {
     "@uipath/filesystem": "workspace:*",
-    "@uipath/flow-converter": "^0.42.1",
-    "@uipath/flow-core": "^0.68.0",
+    "@uipath/flow-converter": "^0.53.6",
+    "@uipath/flow-core": "^0.92.5",
     "@uipath/flow-migrations": "^0.33.0",
-    "@uipath/flow-schema": "^0.42.0",
+    "@uipath/flow-schema": "^0.57.6",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@uipath/tool-agent": "^2.0.0"
   },
   devDependencies: {
     "@types/node": "^25.5.2",
     "@uipath/filesystem": "workspace:*",
-    "@uipath/flow-core": "^0.68.0",
+    "@uipath/flow-core": "^0.92.5",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@uipath/tool-agent": "^2.0.0",
     "@vitest/browser": "^4.1.6",
@@ -148,6 +148,7 @@ async function buildInlineAgentContract(config) {
 }
 var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
   const agentResults = [];
+  const builtAgents = new Map;
   const entries = await fileSystem.readdir(projectPath);
   for (const entry of entries) {
     const sourceDir = Path2.join(projectPath, entry);
@@ -168,11 +169,13 @@ var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
       logger
     });
     agentResults.push(result);
+    builtAgents.set(entry, result.agent);
   }
   const agentBindingResources = agentResults.flatMap(toBindingsResources);
   if (agentBindingResources.length > 0) {
     await mergeAgentBindings(fileSystem, contentFolder, agentBindingResources);
   }
+  return builtAgents;
 };
 
 // src/ensure-process-bindings.ts
@@ -431,15 +434,29 @@ async function readUtf8OrNull(fs, filePath) {
 }
 
 // src/inline-agent-utils.ts
-var INLINE_AGENT_DEF_TYPES = [
-  "uipath.agent.autonomous",
-  "uipath.agent.conversational"
-];
+import { isAgentNodeType } from "@uipath/flow-schema";
+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 isAgentNodeType(type);
+}
 function setPublishIntentOnInlineAgents(fileFormat) {
   const ff = fileFormat;
   for (const def of ff.definitions ?? []) {
     const d = def;
-    if (INLINE_AGENT_DEF_TYPES.includes(d.nodeType)) {
+    if (isInlineAgentNodeType(d.nodeType)) {
       const model = d.model ?? {};
       model.__packageIntent = "Publish";
       d.model = model;
@@ -447,6 +464,80 @@ function setPublishIntentOnInlineAgents(fileFormat) {
   }
 }
 
+// src/operate-runtime-options.ts
+var CONVERSATION_TRIGGER_NODE_TYPE = "core.trigger.conversation";
+function operateRuntimeOptions(nodes) {
+  return nodes.some((node) => node.type === CONVERSATION_TRIGGER_NODE_TYPE) ? { isConversational: true } : undefined;
+}
+
+// src/voice-agent-definitions.ts
+import { isVoiceAgentNodeType } from "@uipath/flow-schema";
+function nodeLabel(node) {
+  const label = node.display?.label;
+  return typeof label === "string" && label.length > 0 ? label : node.id;
+}
+function collectVoiceAgentNodes(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    if (!isVoiceAgentNodeType(node.type))
+      continue;
+    const source = readInlineAgentSource(node);
+    if (!source) {
+      throw new Error(`Voice agent node "${nodeLabel(node)}" has no inputs.source. ` + "Set it to the UUID of the agent directory inside the flow project.");
+    }
+    result.push({ node, source });
+  }
+  return result;
+}
+function buildVoiceAgentDefinitions(nodes, builtAgents) {
+  const definitions = {};
+  for (const { node, source } of collectVoiceAgentNodes(nodes)) {
+    if (definitions[source])
+      continue;
+    const agent = builtAgents.get(source);
+    if (!agent) {
+      throw new Error(`Missing agent definition for voice agent node "${nodeLabel(node)}" (${source}). ` + `Make sure ${source}/agent.json exists in the flow project.`);
+    }
+    definitions[source] = JSON.stringify({
+      ...agent,
+      resources: agent.resources ?? [],
+      features: agent.features ?? []
+    });
+  }
+  return definitions;
+}
+function assertNoSubflowVoiceAgents(flowJson) {
+  const workflow = JSON.parse(flowJson);
+  for (const [subflowId, entry] of Object.entries(workflow.subflows ?? {})) {
+    for (const node of entry.nodes ?? []) {
+      if (!isVoiceAgentNodeType(node.type))
+        continue;
+      throw new Error(`Voice agent node "${nodeLabel(node)}" is inside subflow "${subflowId}". ` + "Voice agent nodes are not supported inside subflows — move it to the top-level flow.");
+    }
+  }
+}
+function voiceConvertOptions(config) {
+  assertNoSubflowVoiceAgents(config.flowJson);
+  const voiceAgentDefinitions = buildVoiceAgentDefinitions(config.nodes, config.builtAgents);
+  if (Object.keys(voiceAgentDefinitions).length === 0) {
+    return config.convertOptions;
+  }
+  const options = {
+    ...config.convertOptions,
+    voiceAgentDefinitions
+  };
+  return options;
+}
+function assertVoiceAgentDefinitionsEmbedded(bpmn, nodes) {
+  const voiceNodes = collectVoiceAgentNodes(nodes);
+  if (voiceNodes.length === 0)
+    return;
+  if (bpmn.includes('name="agentDefinition"'))
+    return;
+  const labels = voiceNodes.map(({ node }) => `"${nodeLabel(node)}"`).join(", ");
+  throw new Error(`Converted BPMN carries no agentDefinition for voice agent node(s) ${labels}. ` + "The installed @uipath/flow-converter does not forward voiceAgentDefinitions " + "to the BPMN serializer — upgrade it. Packaging a voice flow without the " + "embedded agent definition produces a package that deploys but drops every call.");
+}
+
 // src/flow-tool.ts
 var FlowConstants = {
   EntryPointsFileName: "entry-points.json",
@@ -475,12 +566,12 @@ class FlowTool extends ProjectTool {
       this.logger.progress("Copying files...");
       await this.copyProjectFiles(options.projectPath, contentFolder);
       this.logger.progress("Processing agents...");
-      await processAgents(this.fileSystem, this.logger, options.projectPath, contentFolder);
+      const builtAgents = await processAgents(this.fileSystem, this.logger, options.projectPath, contentFolder);
       this.logger.progress("Resolving process bindings...");
       await this.resolveProcessBindings(contentFolder);
       const projectId = options.projectStorageId ?? await ensureProjectId(options.projectPath, this.fileSystem);
       this.logger.progress("Generating packaging artifacts from .flow...");
-      await this.generateFlowPackagingArtifacts(contentFolder, projectId);
+      await this.generateFlowPackagingArtifacts(contentFolder, projectId, builtAgents);
       this.logger.progress("Creating operate.json file...");
       await this.createOperateFile(contentFolder, projectId);
       this.logger.progress("Creating package-descriptor.json file...");
@@ -543,7 +634,7 @@ class FlowTool extends ProjectTool {
       await this.fileSystem.writeFile(flowPath, JSON.stringify(workflow, null, 4));
     }
   }
-  async generateFlowPackagingArtifacts(contentFolder, projectId) {
+  async generateFlowPackagingArtifacts(contentFolder, projectId, builtAgents) {
     const entries = await this.fileSystem.readdir(contentFolder);
     const flowFile = entries.find((e) => e.endsWith(".flow"));
     if (!flowFile) {
@@ -567,8 +658,15 @@ class FlowTool extends ProjectTool {
     const fileFormat = inMemoryWorkflowToFileFormat(workflow);
     setPublishIntentOnInlineAgents(fileFormat);
     const resolvedFlowJson = JSON.stringify(fileFormat);
-    const { bpmn: rawBpmn } = await convertFlowToBpmn(resolvedFlowJson);
+    const flowNodes = workflow.nodes ?? [];
+    const voiceAgents = await this.resolveVoiceAgents(flowNodes, builtAgents, contentFolder);
+    const { bpmn: rawBpmn } = await convertFlowToBpmn(resolvedFlowJson, voiceConvertOptions({
+      flowJson: resolvedFlowJson,
+      nodes: flowNodes,
+      builtAgents: voiceAgents
+    }));
     const bpmn = replaceExporterVersion(rawBpmn, package_default.version);
+    assertVoiceAgentDefinitionsEmbedded(bpmn, flowNodes);
     await this.fileSystem.writeFile(bpmnPath, bpmn);
     const packagingNodes = (workflow.nodes ?? []).map((node) => ({
       id: node.id,
@@ -583,49 +681,24 @@ class FlowTool extends ProjectTool {
     const definitions = workflow.definitions ?? [];
     const entryPointsPath = Path3.join(contentFolder, FlowConstants.EntryPointsFileName);
     const entryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, definitions, ProjectType.Flow);
-    const INLINE_AGENT_TYPES = [
-      "uipath.agent.autonomous",
-      "uipath.agent.conversational"
-    ];
-    const readSource = (n) => {
-      const inputs = n.inputs;
-      const model = n.model;
-      const candidates = [
-        inputs?.source,
-        model?.source,
-        inputs?.agentProjectId,
-        model?.agentProjectId
-      ];
-      for (const c of candidates) {
-        if (typeof c === "string" && c.length > 0)
-          return c;
-      }
-      return;
-    };
     const agentEntryPoints = [];
     const seenSources = new Set;
     for (const node of workflow.nodes ?? []) {
       const n = node;
-      if (!INLINE_AGENT_TYPES.includes(n.type))
+      if (!isInlineAgentNodeType(n.type))
         continue;
-      const source = readSource(n);
+      const source = readInlineAgentSource(n);
       if (!source)
         continue;
       if (seenSources.has(source))
         continue;
       seenSources.add(source);
-      const agentJsonPath = Path3.join(contentFolder, source, "agent.json");
-      if (!await this.fileSystem.exists(agentJsonPath))
-        continue;
-      let agent = {};
-      try {
-        const raw = await this.fileSystem.readFile(agentJsonPath);
-        if (raw) {
-          const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
-          agent = JSON.parse(text);
-        }
-      } catch {
-        continue;
+      let agent = voiceAgents.get(source);
+      if (!agent) {
+        agent = await this.readCopiedAgentJson(contentFolder, source);
+        if (!agent)
+          continue;
+        this.logger.warn(`Inline agent "${source}" has no root-level agent directory, so it ` + "was not built. Its entry point comes from the agent.json copied " + "into the package. Move the agent to the project root to get the " + "full build (migration, validation, binding resources).");
       }
       const inputSchema = agent.inputSchema ?? {
         type: "object",
@@ -655,9 +728,39 @@ class FlowTool extends ProjectTool {
     const startEventMatch = bpmn.match(/<bpmn:startEvent\s+id="([^"]+)"/);
     const startEventId = startEventMatch?.[1] ?? "start";
     const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
-    await this.fileSystem.writeFile(operatePath, `${JSON.stringify(generateOperateJson(projectId || workflow.id || "", mainEntryPoint), null, 2)}
+    const operateJson = generateOperateJson(projectId || workflow.id || "", mainEntryPoint, operateRuntimeOptions(flowNodes));
+    await this.fileSystem.writeFile(operatePath, `${JSON.stringify(operateJson, null, 2)}
 `);
   }
+  async resolveVoiceAgents(flowNodes, builtAgents, contentFolder) {
+    const voiceAgents = new Map(builtAgents);
+    for (const { source } of collectVoiceAgentNodes(flowNodes)) {
+      if (voiceAgents.has(source))
+        continue;
+      const copied = await this.readCopiedAgentJson(contentFolder, source);
+      if (!copied)
+        continue;
+      voiceAgents.set(source, copied);
+      this.logger.warn(`Voice agent "${source}" has no root-level agent directory, so it ` + "was not built. Its embedded definition and entry point come from " + "the agent.json copied into the package. Move the agent to the " + "project root to get the full build (migration, validation, " + "binding resources).");
+    }
+    return voiceAgents;
+  }
+  async readCopiedAgentJson(contentFolder, source) {
+    const agentJsonPath = Path3.join(contentFolder, source, "agent.json");
+    if (!await this.fileSystem.exists(agentJsonPath)) {
+      return;
+    }
+    try {
+      const raw = await this.fileSystem.readFile(agentJsonPath);
+      if (!raw) {
+        return;
+      }
+      const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+      return JSON.parse(text);
+    } catch {
+      return;
+    }
+  }
   async copyProjectFiles(projectPath, contentFolder) {
     await this.fileSystem.mkdir(contentFolder);
     const entries = await this.fileSystem.readdir(projectPath);
@@ -735,16 +838,21 @@ class FlowToolFactory {
 // src/index.ts
 toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory);
 export {
+  voiceConvertOptions,
   setPublishIntentOnInlineAgents,
   resolveWorkflowRefs,
   resolveAndMigrateWorkflow,
   replaceExporterVersion,
+  readInlineAgentSource,
   readFlowWorkflow,
+  operateRuntimeOptions,
   migrateRawWorkflow,
+  isInlineAgentNodeType,
   createFlowRefResolver,
   buildInlineAgentContract,
+  assertVoiceAgentDefinitionsEmbedded,
   FlowToolFactory,
   FlowTool
 };
 
-//# debugId=178D8B52FE90035264756E2164756E21
+//# debugId=7E6DF946A11A786164756E2164756E21

package/dist/inline-agent-utils.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Resolve the inline-agent's projectId UUID from a flow node. Falls back to
+ * the legacy `model.source` / `agentProjectId` aliases so packaging tolerates
+ * already-deployed `.flow` files; `model-source-validator.ts` flags those at
+ * validate time.
+ */
+export declare function readInlineAgentSource(node: {
+    inputs?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+}): string | undefined;
+/** True for a known inline-agent node type. */
+export declare function isInlineAgentNodeType(type: string | undefined): boolean;
 /**
  * Set `__packageIntent = "Publish"` on inline agent definitions in a
  * file-format workflow so the BPMN converter emits "content/" prefixed

package/dist/operate-runtime-options.d.ts

@@ -0,0 +1,10 @@
+/** `runtimeOptions` for a flow's `operate.json`, derived from its nodes. */
+/**
+ * A conversation trigger means the flow can be chatted with, so it packs with
+ * `isConversational: true`. Nothing else sets it.
+ */
+export declare function operateRuntimeOptions(nodes: ReadonlyArray<{
+    type?: string;
+}>): {
+    isConversational: true;
+} | undefined;

package/dist/voice-agent-definitions.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Voice inline agents ship their built agent definition inside the BPMN
+ * (`agentDefinition` on the StartInlineAgentJob activity). The BPMN serializer
+ * writes it from the `voiceAgentDefinitions` convert option; a package without
+ * it deploys and then drops every call, so
+ * {@link assertVoiceAgentDefinitionsEmbedded} fails the build.
+ *
+ * Callers convert the flow themselves — this module only builds the convert
+ * option and checks the result.
+ */
+import type { ConvertOptions } from "@uipath/flow-converter";
+/** `ConvertOptions` plus the `voiceAgentDefinitions` map the serializer reads. */
+export interface VoiceAwareConvertOptions extends ConvertOptions {
+    voiceAgentDefinitions?: Record<string, string>;
+}
+export interface VoiceAgentFlowNode {
+    id: string;
+    type: string;
+    display?: Record<string, unknown>;
+    inputs?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+}
+/** Voice agent nodes with their resolved source UUIDs. */
+export declare function collectVoiceAgentNodes(nodes: VoiceAgentFlowNode[]): Array<{
+    node: VoiceAgentFlowNode;
+    source: string;
+}>;
+/**
+ * Build the `voiceAgentDefinitions` map. `builtAgents` holds each source
+ * UUID's built agent.json (post `buildAgent`).
+ */
+export declare function buildVoiceAgentDefinitions(nodes: VoiceAgentFlowNode[], builtAgents: ReadonlyMap<string, Record<string, unknown>>): Record<string, string>;
+/**
+ * The convert options a flow's voice nodes require: the built definitions the
+ * serializer embeds, merged onto the caller's own options. Returns
+ * `convertOptions` unchanged when the flow has no voice nodes.
+ *
+ * Throws when a voice node sits in a subflow or its agent is missing — before
+ * a BPMN is written, not after.
+ */
+export declare function voiceConvertOptions(config: {
+    /** The resolved file-format workflow, already stringified. */
+    flowJson: string;
+    /** The workflow's nodes — scanned for voice agent nodes. */
+    nodes: VoiceAgentFlowNode[];
+    /** Source UUID → built agent.json for every packaged inline agent. */
+    builtAgents: ReadonlyMap<string, Record<string, unknown>>;
+    /** The caller's own converter options (e.g. `detached` on debug). */
+    convertOptions?: ConvertOptions;
+}): ConvertOptions | undefined;
+/**
+ * Whole-document check: one `agentDefinition` anywhere satisfies it. None at
+ * all means the installed converter dropped the option, which drops every
+ * node at once. Per-node gaps are the serializer's job — it raises on those.
+ */
+export declare function assertVoiceAgentDefinitionsEmbedded(bpmn: string, nodes: VoiceAgentFlowNode[]): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-flow",
-    "version": "1.201.0-preview.131",
+    "version": "1.201.0-preview.133",
     "description": "UiPath Flow tool implementation",
     "type": "module",
     "exports": {
@@ -26,12 +26,12 @@
     "license": "ISC",
     "peerDependencies": {
         "@uipath/filesystem": "1.201.0",
-        "@uipath/flow-converter": "^0.42.1",
-        "@uipath/flow-core": "^0.68.0",
+        "@uipath/flow-converter": "^0.53.6",
+        "@uipath/flow-core": "^0.92.5",
         "@uipath/flow-migrations": "^0.33.0",
-        "@uipath/flow-schema": "^0.42.0",
+        "@uipath/flow-schema": "^0.57.6",
         "@uipath/solutionpackager-tool-core": "1.201.0",
         "@uipath/tool-agent": "^2.0.0"
     },
-    "gitHead": "5b0a03e4ee4be352459ac9fd82341ff77bc82ee6"
+    "gitHead": "7933378ad5276ac369900293a1447474dcec6826"
 }

package/src/agents.ts

@@ -41,13 +41,19 @@ export async function buildInlineAgentContract(config: {
     };
 }
 
+/**
+ * Build every root-level agent directory into the content folder and merge
+ * their binding resources. Returns each built agent.json keyed by its
+ * directory name (the source UUID).
+ */
 export const processAgents = async (
     fileSystem: IFileSystem,
     logger: IToolLogger,
     projectPath: string,
     contentFolder: string,
-): Promise<void> => {
+): Promise<Map<string, Record<string, unknown>>> => {
     const agentResults: AgentBuildResult[] = [];
+    const builtAgents = new Map<string, Record<string, unknown>>();
 
     const entries = await fileSystem.readdir(projectPath);
     for (const entry of entries) {
@@ -72,6 +78,7 @@ export const processAgents = async (
             logger,
         });
         agentResults.push(result);
+        builtAgents.set(entry, result.agent as Record<string, unknown>);
     }
 
     const agentBindingResources = agentResults.flatMap(toBindingsResources);
@@ -82,4 +89,6 @@ export const processAgents = async (
             agentBindingResources,
         );
     }
+
+    return builtAgents;
 };

package/src/flow-tool.ts

@@ -39,7 +39,18 @@ import { processAgents } from "./agents.js";
 import { ensureProcessBindings } from "./ensure-process-bindings.js";
 import { replaceExporterVersion } from "./exporter-version.js";
 import { readFlowWorkflow } from "./flow-io.js";
-import { setPublishIntentOnInlineAgents } from "./inline-agent-utils.js";
+import {
+    isInlineAgentNodeType,
+    readInlineAgentSource,
+    setPublishIntentOnInlineAgents,
+} from "./inline-agent-utils.js";
+import { operateRuntimeOptions } from "./operate-runtime-options.js";
+import {
+    assertVoiceAgentDefinitionsEmbedded,
+    collectVoiceAgentNodes,
+    type VoiceAgentFlowNode,
+    voiceConvertOptions,
+} from "./voice-agent-definitions.js";
 
 const FlowConstants = {
     EntryPointsFileName: "entry-points.json",
@@ -94,7 +105,7 @@ export class FlowTool extends ProjectTool {
             await this.copyProjectFiles(options.projectPath, contentFolder);
 
             this.logger.progress("Processing agents...");
-            await processAgents(
+            const builtAgents = await processAgents(
                 this.fileSystem,
                 this.logger,
                 options.projectPath,
@@ -111,7 +122,11 @@ export class FlowTool extends ProjectTool {
             this.logger.progress(
                 "Generating packaging artifacts from .flow...",
             );
-            await this.generateFlowPackagingArtifacts(contentFolder, projectId);
+            await this.generateFlowPackagingArtifacts(
+                contentFolder,
+                projectId,
+                builtAgents,
+            );
 
             this.logger.progress("Creating operate.json file...");
             await this.createOperateFile(contentFolder, projectId);
@@ -231,6 +246,7 @@ export class FlowTool extends ProjectTool {
     private async generateFlowPackagingArtifacts(
         contentFolder: string,
         projectId: string,
+        builtAgents: ReadonlyMap<string, Record<string, unknown>>,
     ): Promise<void> {
         // Find the .flow file in content folder
         const entries = await this.fileSystem.readdir(contentFolder);
@@ -266,8 +282,28 @@ export class FlowTool extends ProjectTool {
         const fileFormat = inMemoryWorkflowToFileFormat(workflow);
         setPublishIntentOnInlineAgents(fileFormat);
         const resolvedFlowJson = JSON.stringify(fileFormat);
-        const { bpmn: rawBpmn } = await convertFlowToBpmn(resolvedFlowJson);
+
+        // `builtAgents` holds only what processAgents built (root-level agent
+        // dirs). A voice agent that reached the content folder some other way
+        // (a Studio Web download's `content/<uuid>/` layout) still has to
+        // embed a definition — a BPMN without one deploys and then drops
+        // every call — so fall back to its copied agent.json.
+        const flowNodes = (workflow.nodes ?? []) as VoiceAgentFlowNode[];
+        const voiceAgents = await this.resolveVoiceAgents(
+            flowNodes,
+            builtAgents,
+            contentFolder,
+        );
+        const { bpmn: rawBpmn } = await convertFlowToBpmn(
+            resolvedFlowJson,
+            voiceConvertOptions({
+                flowJson: resolvedFlowJson,
+                nodes: flowNodes,
+                builtAgents: voiceAgents,
+            }),
+        );
         const bpmn = replaceExporterVersion(rawBpmn, pkg.version);
+        assertVoiceAgentDefinitionsEmbedded(bpmn, flowNodes);
         await this.fileSystem.writeFile(bpmnPath, bpmn);
 
         // Map file-format nodes to flat PackagingNode shape so
@@ -303,66 +339,33 @@ export class FlowTool extends ProjectTool {
             ProjectType.Flow,
         );
 
-        // Scan for inline agent nodes and add their entry points.
-        // The source UUID lives at `inputs.source` (canonical post
-        // flow-core 0.2.50) or `model.source` (legacy). Validation
-        // accepts both, so packaging must too — otherwise legacy flows
-        // produce a .nupkg whose entry-points.json silently omits the
-        // agent, and runtime returns 404 for `StartInlineAgentJob`.
-        //
-        // Canonical copy of this resolution rule lives at
-        // `flow-tool/src/services/packaging-utils.ts:readInlineAgentSource`.
-        // It's duplicated here (rather than imported) because `flow-tool`
-        // already depends on this package, so the reverse import would
-        // be a cycle. Keep both in sync; longer-term the helper should
-        // move to `@uipath/flow-schema` (an external dep both can share).
-        const INLINE_AGENT_TYPES = [
-            "uipath.agent.autonomous",
-            "uipath.agent.conversational",
-        ];
-        const readSource = (n: Record<string, unknown>): string | undefined => {
-            const inputs = n.inputs as Record<string, unknown> | undefined;
-            const model = n.model as Record<string, unknown> | undefined;
-            const candidates: unknown[] = [
-                inputs?.source,
-                model?.source,
-                inputs?.agentProjectId,
-                model?.agentProjectId,
-            ];
-            for (const c of candidates) {
-                if (typeof c === "string" && c.length > 0) return c;
-            }
-            return undefined;
-        };
+        // `readInlineAgentSource` accepts the legacy `model.source` too, the
+        // same as validation; otherwise entry-points.json omits the agent and
+        // runtime 404s on `StartInlineAgentJob`.
         const agentEntryPoints: EntryPoint[] = [];
         const seenSources = new Set<string>();
         for (const node of workflow.nodes ?? []) {
             const n = node as Record<string, unknown>;
-            if (!INLINE_AGENT_TYPES.includes(n.type as string)) continue;
-            const source = readSource(n);
+            if (!isInlineAgentNodeType(n.type as string)) continue;
+            const source = readInlineAgentSource(n);
             if (!source) continue;
             if (seenSources.has(source)) continue;
             seenSources.add(source);
 
-            const agentJsonPath = Path.join(
-                contentFolder,
-                source,
-                "agent.json",
-            );
-            if (!(await this.fileSystem.exists(agentJsonPath))) continue;
-
-            let agent: Record<string, unknown> = {};
-            try {
-                const raw = await this.fileSystem.readFile(agentJsonPath);
-                if (raw) {
-                    const text =
-                        typeof raw === "string"
-                            ? raw
-                            : new TextDecoder().decode(raw);
-                    agent = JSON.parse(text) as Record<string, unknown>;
-                }
-            } catch {
-                continue;
+            // `processAgents` only scans root-level agent dirs, so a
+            // `content/<uuid>/` layout is copied but never built.
+            // `voiceAgents` already carries the copied fallback for voice
+            // sources (and their warn), so those don't warn twice here.
+            let agent = voiceAgents.get(source);
+            if (!agent) {
+                agent = await this.readCopiedAgentJson(contentFolder, source);
+                if (!agent) continue;
+                this.logger.warn(
+                    `Inline agent "${source}" has no root-level agent directory, so it ` +
+                        "was not built. Its entry point comes from the agent.json copied " +
+                        "into the package. Move the agent to the project root to get the " +
+                        "full build (migration, validation, binding resources).",
+                );
             }
 
             const inputSchema = (agent.inputSchema ?? {
@@ -412,12 +415,72 @@ export class FlowTool extends ProjectTool {
         const startEventMatch = bpmn.match(/<bpmn:startEvent\s+id="([^"]+)"/);
         const startEventId = startEventMatch?.[1] ?? "start";
         const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
+        const operateJson = generateOperateJson(
+            projectId || workflow.id || "",
+            mainEntryPoint,
+            operateRuntimeOptions(flowNodes),
+        );
         await this.fileSystem.writeFile(
             operatePath,
-            `${JSON.stringify(generateOperateJson(projectId || workflow.id || "", mainEntryPoint), null, 2)}\n`,
+            `${JSON.stringify(operateJson, null, 2)}\n`,
         );
     }
 
+    /**
+     * `builtAgents` plus, for each voice node whose agent was not built, the
+     * agent.json copied into the content folder. Voice nodes embed the
+     * definition into the BPMN, so — unlike text agents — a source missing
+     * from the map fails the whole build, not just an entry point.
+     * A source with no copied agent.json stays absent;
+     * `buildVoiceAgentDefinitions` reports it.
+     */
+    private async resolveVoiceAgents(
+        flowNodes: VoiceAgentFlowNode[],
+        builtAgents: ReadonlyMap<string, Record<string, unknown>>,
+        contentFolder: string,
+    ): Promise<Map<string, Record<string, unknown>>> {
+        const voiceAgents = new Map(builtAgents);
+        for (const { source } of collectVoiceAgentNodes(flowNodes)) {
+            if (voiceAgents.has(source)) continue;
+            const copied = await this.readCopiedAgentJson(
+                contentFolder,
+                source,
+            );
+            if (!copied) continue;
+            voiceAgents.set(source, copied);
+            this.logger.warn(
+                `Voice agent "${source}" has no root-level agent directory, so it ` +
+                    "was not built. Its embedded definition and entry point come from " +
+                    "the agent.json copied into the package. Move the agent to the " +
+                    "project root to get the full build (migration, validation, " +
+                    "binding resources).",
+            );
+        }
+        return voiceAgents;
+    }
+
+    /** Read an `agent.json` copied in without going through `buildAgent`. */
+    private async readCopiedAgentJson(
+        contentFolder: string,
+        source: string,
+    ): Promise<Record<string, unknown> | undefined> {
+        const agentJsonPath = Path.join(contentFolder, source, "agent.json");
+        if (!(await this.fileSystem.exists(agentJsonPath))) {
+            return undefined;
+        }
+        try {
+            const raw = await this.fileSystem.readFile(agentJsonPath);
+            if (!raw) {
+                return undefined;
+            }
+            const text =
+                typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+            return JSON.parse(text) as Record<string, unknown>;
+        } catch {
+            return undefined;
+        }
+    }
+
     /**
      * Copy project files into the correct nupkg structure.
      *

package/src/index.ts

@@ -23,6 +23,16 @@ export {
 } from "./flow-io.js";
 export { FlowTool } from "./flow-tool.js";
 export { FlowToolFactory } from "./flow-tool-factory.js";
-export { setPublishIntentOnInlineAgents } from "./inline-agent-utils.js";
+export {
+    isInlineAgentNodeType,
+    readInlineAgentSource,
+    setPublishIntentOnInlineAgents,
+} from "./inline-agent-utils.js";
+export { operateRuntimeOptions } from "./operate-runtime-options.js";
+export {
+    assertVoiceAgentDefinitionsEmbedded,
+    type VoiceAgentFlowNode,
+    voiceConvertOptions,
+} from "./voice-agent-definitions.js";
 
 toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory());

package/src/inline-agent-utils.ts

@@ -1,7 +1,33 @@
-const INLINE_AGENT_DEF_TYPES = [
-    "uipath.agent.autonomous",
-    "uipath.agent.conversational",
-];
+import { isAgentNodeType } from "@uipath/flow-schema";
+
+/**
+ * Resolve the inline-agent's projectId UUID from a flow node. Falls back to
+ * the legacy `model.source` / `agentProjectId` aliases so packaging tolerates
+ * already-deployed `.flow` files; `model-source-validator.ts` flags those at
+ * validate time.
+ */
+export function readInlineAgentSource(node: {
+    inputs?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+}): string | undefined {
+    const candidates: unknown[] = [
+        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 undefined;
+}
+
+/** True for a known inline-agent node type. */
+export function isInlineAgentNodeType(type: string | undefined): boolean {
+    return isAgentNodeType(type);
+}
 
 /**
  * Set `__packageIntent = "Publish"` on inline agent definitions in a
@@ -14,7 +40,7 @@ export function setPublishIntentOnInlineAgents(fileFormat: unknown): void {
     const ff = fileFormat as Record<string, unknown[]>;
     for (const def of ff.definitions ?? []) {
         const d = def as Record<string, unknown>;
-        if (INLINE_AGENT_DEF_TYPES.includes(d.nodeType as string)) {
+        if (isInlineAgentNodeType(d.nodeType as string)) {
             const model = (d.model ?? {}) as Record<string, unknown>;
             model.__packageIntent = "Publish";
             d.model = model;

package/src/operate-runtime-options.ts

@@ -0,0 +1,15 @@
+/** `runtimeOptions` for a flow's `operate.json`, derived from its nodes. */
+
+const CONVERSATION_TRIGGER_NODE_TYPE = "core.trigger.conversation";
+
+/**
+ * A conversation trigger means the flow can be chatted with, so it packs with
+ * `isConversational: true`. Nothing else sets it.
+ */
+export function operateRuntimeOptions(
+    nodes: ReadonlyArray<{ type?: string }>,
+): { isConversational: true } | undefined {
+    return nodes.some((node) => node.type === CONVERSATION_TRIGGER_NODE_TYPE)
+        ? { isConversational: true }
+        : undefined;
+}

package/src/voice-agent-definitions.ts

@@ -0,0 +1,155 @@
+/**
+ * Voice inline agents ship their built agent definition inside the BPMN
+ * (`agentDefinition` on the StartInlineAgentJob activity). The BPMN serializer
+ * writes it from the `voiceAgentDefinitions` convert option; a package without
+ * it deploys and then drops every call, so
+ * {@link assertVoiceAgentDefinitionsEmbedded} fails the build.
+ *
+ * Callers convert the flow themselves — this module only builds the convert
+ * option and checks the result.
+ */
+
+import type { ConvertOptions } from "@uipath/flow-converter";
+import { isVoiceAgentNodeType } from "@uipath/flow-schema";
+
+import { readInlineAgentSource } from "./inline-agent-utils.js";
+
+/** `ConvertOptions` plus the `voiceAgentDefinitions` map the serializer reads. */
+export interface VoiceAwareConvertOptions extends ConvertOptions {
+    voiceAgentDefinitions?: Record<string, string>;
+}
+
+export interface VoiceAgentFlowNode {
+    id: string;
+    type: string;
+    display?: Record<string, unknown>;
+    inputs?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+}
+
+function nodeLabel(node: VoiceAgentFlowNode): string {
+    const label = node.display?.label;
+    return typeof label === "string" && label.length > 0 ? label : node.id;
+}
+
+/** Voice agent nodes with their resolved source UUIDs. */
+export function collectVoiceAgentNodes(
+    nodes: VoiceAgentFlowNode[],
+): Array<{ node: VoiceAgentFlowNode; source: string }> {
+    const result: Array<{ node: VoiceAgentFlowNode; source: string }> = [];
+    for (const node of nodes) {
+        if (!isVoiceAgentNodeType(node.type)) continue;
+        const source = readInlineAgentSource(node);
+        if (!source) {
+            throw new Error(
+                `Voice agent node "${nodeLabel(node)}" has no inputs.source. ` +
+                    "Set it to the UUID of the agent directory inside the flow project.",
+            );
+        }
+        result.push({ node, source });
+    }
+    return result;
+}
+
+/**
+ * Build the `voiceAgentDefinitions` map. `builtAgents` holds each source
+ * UUID's built agent.json (post `buildAgent`).
+ */
+export function buildVoiceAgentDefinitions(
+    nodes: VoiceAgentFlowNode[],
+    builtAgents: ReadonlyMap<string, Record<string, unknown>>,
+): Record<string, string> {
+    const definitions: Record<string, string> = {};
+    for (const { node, source } of collectVoiceAgentNodes(nodes)) {
+        if (definitions[source]) continue;
+        const agent = builtAgents.get(source);
+        if (!agent) {
+            throw new Error(
+                `Missing agent definition for voice agent node "${nodeLabel(node)}" (${source}). ` +
+                    `Make sure ${source}/agent.json exists in the flow project.`,
+            );
+        }
+        definitions[source] = JSON.stringify({
+            ...agent,
+            resources: (agent.resources as unknown[]) ?? [],
+            features: (agent.features as unknown[]) ?? [],
+        });
+    }
+    return definitions;
+}
+
+/**
+ * Only top-level voice nodes get definitions, so a subflow one would ship a
+ * serviceTask with no `agentDefinition`. The CLI validate rule rejects the
+ * same flow; both go away when the platform supports it.
+ */
+function assertNoSubflowVoiceAgents(flowJson: string): void {
+    const workflow = JSON.parse(flowJson) as {
+        subflows?: Record<string, { nodes?: VoiceAgentFlowNode[] }>;
+    };
+    for (const [subflowId, entry] of Object.entries(workflow.subflows ?? {})) {
+        for (const node of entry.nodes ?? []) {
+            if (!isVoiceAgentNodeType(node.type)) continue;
+            throw new Error(
+                `Voice agent node "${nodeLabel(node)}" is inside subflow "${subflowId}". ` +
+                    "Voice agent nodes are not supported inside subflows — move it to the top-level flow.",
+            );
+        }
+    }
+}
+
+/**
+ * The convert options a flow's voice nodes require: the built definitions the
+ * serializer embeds, merged onto the caller's own options. Returns
+ * `convertOptions` unchanged when the flow has no voice nodes.
+ *
+ * Throws when a voice node sits in a subflow or its agent is missing — before
+ * a BPMN is written, not after.
+ */
+export function voiceConvertOptions(config: {
+    /** The resolved file-format workflow, already stringified. */
+    flowJson: string;
+    /** The workflow's nodes — scanned for voice agent nodes. */
+    nodes: VoiceAgentFlowNode[];
+    /** Source UUID → built agent.json for every packaged inline agent. */
+    builtAgents: ReadonlyMap<string, Record<string, unknown>>;
+    /** The caller's own converter options (e.g. `detached` on debug). */
+    convertOptions?: ConvertOptions;
+}): ConvertOptions | undefined {
+    assertNoSubflowVoiceAgents(config.flowJson);
+    const voiceAgentDefinitions = buildVoiceAgentDefinitions(
+        config.nodes,
+        config.builtAgents,
+    );
+    if (Object.keys(voiceAgentDefinitions).length === 0) {
+        return config.convertOptions;
+    }
+    const options: VoiceAwareConvertOptions = {
+        ...config.convertOptions,
+        voiceAgentDefinitions,
+    };
+    return options;
+}
+
+/**
+ * Whole-document check: one `agentDefinition` anywhere satisfies it. None at
+ * all means the installed converter dropped the option, which drops every
+ * node at once. Per-node gaps are the serializer's job — it raises on those.
+ */
+export function assertVoiceAgentDefinitionsEmbedded(
+    bpmn: string,
+    nodes: VoiceAgentFlowNode[],
+): void {
+    const voiceNodes = collectVoiceAgentNodes(nodes);
+    if (voiceNodes.length === 0) return;
+    if (bpmn.includes('name="agentDefinition"')) return;
+    const labels = voiceNodes
+        .map(({ node }) => `"${nodeLabel(node)}"`)
+        .join(", ");
+    throw new Error(
+        `Converted BPMN carries no agentDefinition for voice agent node(s) ${labels}. ` +
+            "The installed @uipath/flow-converter does not forward voiceAgentDefinitions " +
+            "to the BPMN serializer — upgrade it. Packaging a voice flow without the " +
+            "embedded agent definition produces a package that deploys but drops every call.",
+    );
+}