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

package/dist/agent-input-encoding-utils.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Encoding-agnostic readers for the inline-agent input encoding (MST-12020).
+ *
+ * flow-workbench writes inline-agent input names in one of two schemes, gated by its
+ * `services.agent-storage.nested-agent-input-schema` feature flag:
+ *  - FLAT (shipped default): one top-level `inputSchema` property per input, `__`-joined
+ *    (`script1__output__query`), prompts read `{{input.script1__output__query}}`.
+ *  - NESTED (flag on): a nested object tree whose auto-created container nodes carry
+ *    `x-uipath-container: true`, prompts read `{{input.script1.output.query}}` (the runtime
+ *    template engine treats `.` as navigation).
+ *
+ * The CLI must read BOTH — an agent.json is whatever the authoring canvas last wrote — so these
+ * helpers detect per file instead of consuming any flag. Detection is strictly the per-node
+ * container marker: an object property WITHOUT the marker is a user-declared whole-object input
+ * under either encoding and must be treated as one leaf, never unfolded.
+ *
+ * TODO: replace with flow-workbench's canonical helpers (`collectInlineAgentInputsFromAgent`,
+ * `decodeFlatName`, `getContainerChildProps`) once they are re-exported from
+ * `@uipath/flow-converter` — that package is the single source of truth for the encoding.
+ */
+/** Marker flow-workbench stamps on auto-created container nodes of a NESTED inputSchema. */
+export declare const SCHEMA_CONTAINER_MARKER = "x-uipath-container";
+/** One bindable input leaf of an agent `inputSchema`, in both name forms. */
+export interface AgentInputLeaf {
+    /** Flat `__`-joined name — what a flat prompt token / flat JobArgument uses. */
+    flatKey: string;
+    /** Canonical dotted path — what a nested prompt token navigates. */
+    path: string;
+    /** Declared `type` of the leaf node, when present. */
+    type?: string;
+}
+/** Canonical dotted form of an input name from either encoding (`a__b` and `a.b` → `a.b`). */
+export declare function canonicalAgentInputPath(name: string): string;
+/**
+ * Enumerate the bindable input leaves of an agent `inputSchema`, descending MARKED containers
+ * (nested encoding) and passing flat / declared-object top-level keys through as single leaves.
+ * Returns `[]` for an absent/empty/malformed schema.
+ */
+export declare function collectAgentInputLeaves(inputSchema: unknown): AgentInputLeaf[];
+/**
+ * Source binding expression for one input leaf — the inverse of flow-workbench's encode:
+ * a `metadata`-rooted path binds `$metadata.*`; everything else binds `$vars.*`.
+ */
+export declare function leafToBinding(leaf: AgentInputLeaf): string;

package/dist/agents.d.ts

@@ -8,7 +8,9 @@ export interface InlineAgentContract {
 }
 /**
  * Build the execution contract for one inline agent with the same migration,
- * validation, and binding pipeline used by normal solution packaging.
+ * validation, and binding pipeline used by normal solution packaging. The
+ * returned `agentJson` is healed to the flat input encoding (MST-12020) — see
+ * {@link healAgentInputEncoding}.
  */
 export declare function buildInlineAgentContract(config: {
     fileSystem: IFileSystem;

package/dist/flow-tool.d.ts

@@ -37,6 +37,15 @@ export declare class FlowTool extends ProjectTool {
      * `buildVoiceAgentDefinitions` reports it.
      */
     private resolveVoiceAgents;
+    /**
+     * Reconcile each inline-agent node's `agentInputVariables` from its
+     * agent's `inputSchema` before conversion. Reads the schema from the
+     * already-built agent (`builtAgents`) first, falling back to an
+     * `agent.json` copied under `content/<source>/`. Mutates `workflow.nodes`
+     * in place; best-effort, so a missing/unreadable agent leaves the node
+     * as-is.
+     */
+    private hydrateInlineAgentInputs;
     /** Read an `agent.json` copied in without going through `buildAgent`. */
     private readCopiedAgentJson;
     /**

package/dist/index.d.ts

@@ -1,8 +1,9 @@
+export { type AgentInputLeaf, canonicalAgentInputPath, collectAgentInputLeaves, leafToBinding, SCHEMA_CONTAINER_MARKER, } from "./agent-input-encoding-utils.js";
 export { buildInlineAgentContract, type InlineAgentContract, } from "./agents.js";
 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 { isInlineAgentNodeType, readInlineAgentSource, setPublishIntentOnInlineAgents, } from "./inline-agent-utils.js";
+export { type AgentInputVariable, hydrateInlineAgentInputVariables, isInlineAgentNodeType, readInlineAgentSource, reconcileInlineAgentInputVariables, 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.133",
+  version: "1.202.0-preview.134",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -75,17 +75,18 @@ var package_default = {
   license: "ISC",
   peerDependencies: {
     "@uipath/filesystem": "workspace:*",
-    "@uipath/flow-converter": "^0.53.6",
-    "@uipath/flow-core": "^0.92.5",
-    "@uipath/flow-migrations": "^0.33.0",
-    "@uipath/flow-schema": "^0.57.6",
+    "@uipath/flow-converter": "0.55.0-develop",
+    "@uipath/flow-core": "0.96.0-develop",
+    "@uipath/flow-migrations": "0.45.0-develop",
+    "@uipath/flow-schema": "0.57.4-develop",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@uipath/tool-agent": "^2.0.0"
   },
   devDependencies: {
     "@types/node": "^25.5.2",
     "@uipath/filesystem": "workspace:*",
-    "@uipath/flow-core": "^0.92.5",
+    "@uipath/flow-converter": "0.55.0-develop",
+    "@uipath/flow-core": "0.96.0-develop",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@uipath/tool-agent": "^2.0.0",
     "@vitest/browser": "^4.1.6",
@@ -98,6 +99,10 @@ var package_default = {
 };
 
 // src/agents.ts
+import {
+  healResourceInputEncoding,
+  normalizeAgentInputEncoding
+} from "@uipath/flow-converter";
 import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
 import { buildAgent } from "@uipath/tool-agent/build";
 
@@ -139,13 +144,19 @@ async function buildInlineAgentContract(config) {
     options: { writeBindings: false }
   });
   return {
-    agentJson: built.agent,
+    agentJson: healAgentInputEncoding(built.agent),
     bindingsJson: {
       version: built.bindings.version,
       resources: built.bindings.resources
     }
   };
 }
+function healAgentInputEncoding(agent) {
+  const normalized = normalizeAgentInputEncoding(agent);
+  const rawResources = normalized.resources;
+  const resources = Array.isArray(rawResources) ? rawResources.map((resource) => resource && typeof resource === "object" && !Array.isArray(resource) ? healResourceInputEncoding(resource) : resource) : rawResources;
+  return { ...normalized, resources };
+}
 var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
   const agentResults = [];
   const builtAgents = new Map;
@@ -168,8 +179,13 @@ var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
       outputPath: outputDir,
       logger
     });
+    let agentJson = result.agent;
+    if (agentJson) {
+      agentJson = healAgentInputEncoding(agentJson);
+      await fileSystem.writeFile(Path2.join(outputDir, "agent.json"), JSON.stringify(agentJson, null, 2));
+    }
     agentResults.push(result);
-    builtAgents.set(entry, result.agent);
+    builtAgents.set(entry, agentJson);
   }
   const agentBindingResources = agentResults.flatMap(toBindingsResources);
   if (agentBindingResources.length > 0) {
@@ -434,7 +450,57 @@ async function readUtf8OrNull(fs, filePath) {
 }
 
 // src/inline-agent-utils.ts
-import { isAgentNodeType } from "@uipath/flow-schema";
+import { isAgentNodeType, isVoiceAgentNodeType } from "@uipath/flow-schema";
+
+// src/agent-input-encoding-utils.ts
+var SCHEMA_CONTAINER_MARKER = "x-uipath-container";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function containerChildren(prop) {
+  if (!isRecord(prop))
+    return;
+  if (prop[SCHEMA_CONTAINER_MARKER] !== true)
+    return;
+  const children = prop.properties;
+  return isRecord(children) ? children : undefined;
+}
+function canonicalAgentInputPath(name) {
+  return name.split("__").join(".");
+}
+function collectAgentInputLeaves(inputSchema) {
+  const properties = isRecord(inputSchema) ? inputSchema.properties : undefined;
+  if (!isRecord(properties))
+    return [];
+  const leaves = [];
+  const walk = (prop, segments) => {
+    const children = containerChildren(prop);
+    if (!children) {
+      const flatKey = segments.join("__");
+      leaves.push({
+        flatKey,
+        path: canonicalAgentInputPath(segments.join(".")),
+        type: isRecord(prop) && typeof prop.type === "string" ? prop.type : undefined
+      });
+      return;
+    }
+    for (const [key, child] of Object.entries(children)) {
+      walk(child, [...segments, key]);
+    }
+  };
+  for (const [key, prop] of Object.entries(properties)) {
+    walk(prop, [key]);
+  }
+  return leaves;
+}
+function leafToBinding(leaf) {
+  const segments = leaf.path.split(".");
+  if (segments[0] === "metadata") {
+    const rest = segments.slice(1).join(".");
+    return rest ? `=$metadata.${rest}` : "=$metadata";
+  }
+  return `=$vars.${leaf.path}`;
+}
+
+// src/inline-agent-utils.ts
 function readInlineAgentSource(node) {
   const candidates = [
     node.inputs?.source,
@@ -452,6 +518,55 @@ function readInlineAgentSource(node) {
 function isInlineAgentNodeType(type) {
   return isAgentNodeType(type);
 }
+function reconcileInlineAgentInputVariables(existing, inputSchema) {
+  const leaves = collectAgentInputLeaves(inputSchema);
+  if (leaves.length === 0) {
+    return { variables: existing, added: 0 };
+  }
+  const existingPaths = new Set(existing.map((e) => e.id).filter((id) => typeof id === "string").map(canonicalAgentInputPath));
+  const additions = leaves.filter((leaf) => !existingPaths.has(leaf.path)).map((leaf) => {
+    const binding = leafToBinding(leaf);
+    return {
+      id: leaf.flatKey,
+      type: leaf.type ?? "string",
+      binding,
+      description: `Bound from ${binding.slice(1)}`
+    };
+  });
+  if (additions.length === 0) {
+    return { variables: existing, added: 0 };
+  }
+  return { variables: [...existing, ...additions], added: additions.length };
+}
+async function hydrateInlineAgentInputVariables(nodes, resolveInputSchema, onReconcile, onUnresolved) {
+  for (const node of nodes) {
+    if (!isInlineAgentNodeType(node.type))
+      continue;
+    const source = readInlineAgentSource(node);
+    if (!source)
+      continue;
+    const reportable = !isVoiceAgentNodeType(node.type);
+    if (/[/\\.]/.test(source)) {
+      if (reportable)
+        onUnresolved?.(source, "invalid-source");
+      continue;
+    }
+    const inputSchema = await resolveInputSchema(source);
+    if (inputSchema === undefined) {
+      if (reportable)
+        onUnresolved?.(source, "schema-unavailable");
+      continue;
+    }
+    const existing = Array.isArray(node.inputs?.agentInputVariables) ? node.inputs.agentInputVariables : [];
+    const { variables, added } = reconcileInlineAgentInputVariables(existing, inputSchema);
+    if (added === 0)
+      continue;
+    if (!node.inputs)
+      node.inputs = {};
+    node.inputs.agentInputVariables = variables;
+    onReconcile?.(source, added);
+  }
+}
 function setPublishIntentOnInlineAgents(fileFormat) {
   const ff = fileFormat;
   for (const def of ff.definitions ?? []) {
@@ -471,7 +586,7 @@ function operateRuntimeOptions(nodes) {
 }
 
 // src/voice-agent-definitions.ts
-import { isVoiceAgentNodeType } from "@uipath/flow-schema";
+import { isVoiceAgentNodeType as isVoiceAgentNodeType2 } from "@uipath/flow-schema";
 function nodeLabel(node) {
   const label = node.display?.label;
   return typeof label === "string" && label.length > 0 ? label : node.id;
@@ -479,7 +594,7 @@ function nodeLabel(node) {
 function collectVoiceAgentNodes(nodes) {
   const result = [];
   for (const node of nodes) {
-    if (!isVoiceAgentNodeType(node.type))
+    if (!isVoiceAgentNodeType2(node.type))
       continue;
     const source = readInlineAgentSource(node);
     if (!source) {
@@ -510,7 +625,7 @@ 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))
+      if (!isVoiceAgentNodeType2(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.");
     }
@@ -653,6 +768,7 @@ class FlowTool extends ProjectTool {
       this.logger.warn(`Could not load ${flowFile} as a workflow — skipping artifact generation: ${message}`);
       return;
     }
+    await this.hydrateInlineAgentInputs(workflow, builtAgents, contentFolder);
     const bpmnFileName = flowFile.replace(/\.flow$/, ".bpmn");
     const bpmnPath = Path3.join(contentFolder, bpmnFileName);
     const fileFormat = inMemoryWorkflowToFileFormat(workflow);
@@ -745,6 +861,13 @@ class FlowTool extends ProjectTool {
     }
     return voiceAgents;
   }
+  async hydrateInlineAgentInputs(workflow, builtAgents, contentFolder) {
+    const nodes = workflow.nodes ?? [];
+    await hydrateInlineAgentInputVariables(nodes, async (source) => {
+      const agent = builtAgents.get(source) ?? await this.readCopiedAgentJson(contentFolder, source);
+      return agent?.inputSchema;
+    }, (source, added) => this.logger.info(`Reconciled ${added} inline-agent input(s) for "${source}" from agent.json inputSchema`), (source, reason) => this.logger.warn(reason === "invalid-source" ? `Inline agent "${source}" is not a bare project-id folder, so its inputs were not reconciled and packaging skips it — the agent would ship with no bound inputs.` : `Could not read an inputSchema for inline agent "${source}", so its inputs were not reconciled — the agent would ship with no bound inputs. Check that ${source}/agent.json exists and parses.`));
+  }
   async readCopiedAgentJson(contentFolder, source) {
     const agentJsonPath = Path3.join(contentFolder, source, "agent.json");
     if (!await this.fileSystem.exists(agentJsonPath)) {
@@ -838,21 +961,27 @@ class FlowToolFactory {
 // src/index.ts
 toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory);
 export {
-  voiceConvertOptions,
-  setPublishIntentOnInlineAgents,
-  resolveWorkflowRefs,
-  resolveAndMigrateWorkflow,
-  replaceExporterVersion,
-  readInlineAgentSource,
-  readFlowWorkflow,
-  operateRuntimeOptions,
-  migrateRawWorkflow,
-  isInlineAgentNodeType,
-  createFlowRefResolver,
-  buildInlineAgentContract,
-  assertVoiceAgentDefinitionsEmbedded,
+  FlowTool,
   FlowToolFactory,
-  FlowTool
+  SCHEMA_CONTAINER_MARKER,
+  assertVoiceAgentDefinitionsEmbedded,
+  buildInlineAgentContract,
+  canonicalAgentInputPath,
+  collectAgentInputLeaves,
+  createFlowRefResolver,
+  hydrateInlineAgentInputVariables,
+  isInlineAgentNodeType,
+  leafToBinding,
+  migrateRawWorkflow,
+  operateRuntimeOptions,
+  readFlowWorkflow,
+  readInlineAgentSource,
+  reconcileInlineAgentInputVariables,
+  replaceExporterVersion,
+  resolveAndMigrateWorkflow,
+  resolveWorkflowRefs,
+  setPublishIntentOnInlineAgents,
+  voiceConvertOptions
 };
 
-//# debugId=7E6DF946A11A786164756E2164756E21
+//# debugId=A6C01CA5DD3E27EB64756E2164756E21

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

@@ -10,6 +10,73 @@ export declare function readInlineAgentSource(node: {
 }): string | undefined;
 /** True for a known inline-agent node type. */
 export declare function isInlineAgentNodeType(type: string | undefined): boolean;
+/** One flow-node `agentInputVariables[]` entry. */
+export interface AgentInputVariable {
+    id?: string;
+    type?: string;
+    binding?: string;
+    description?: string;
+}
+/**
+ * Reconcile a node's existing `agentInputVariables` against an agent's
+ * `inputSchema` — the input contract the runtime actually binds.
+ *
+ * Adds a derived entry for every input leaf the node is missing and preserves
+ * every entry the node already declares, so a custom or divergent binding is
+ * never clobbered. Leaves come from {@link collectAgentInputLeaves}, so a
+ * nested schema descends its marked containers rather than being read as one
+ * opaque top-level key.
+ *
+ * Comparison is on the canonical dotted path, so a node that declares the
+ * nested spelling (`a.b`) is not re-added under the flat one (`a__b`). The
+ * derived id is always the FLAT spelling: the packager heals the shipped
+ * agent.json prompts and schema to the flat encoding, and the converter emits
+ * each id verbatim as a JobArgument name, so flat ids are what match the
+ * healed `{{input.<flat>}}` tokens for both schema encodings.
+ *
+ * Returns the reconciled list plus how many entries were added; when nothing
+ * is missing (or the schema is empty) returns the original array unchanged so
+ * callers can skip a spurious mutation.
+ */
+export declare function reconcileInlineAgentInputVariables(existing: AgentInputVariable[], inputSchema: unknown): {
+    variables: AgentInputVariable[];
+    added: number;
+};
+/** Minimal shape of a flow node needed to hydrate inline-agent inputs. */
+interface InlineAgentNodeLike {
+    type?: string;
+    inputs?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+}
+/**
+ * Reconcile every inline-agent node's `agentInputVariables` against its
+ * agent's `inputSchema` before BPMN conversion. Mutates `nodes` in place.
+ *
+ * Studio Web keeps the input binding in the agent's `inputSchema` and rebuilds
+ * the node's `agentInputVariables` from it in memory on load; the `.flow` it
+ * writes carries an empty `agentInputVariables`. The converter derives the
+ * agent's `JobArguments` from `agentInputVariables` and never reads
+ * `agent.json`, so an SW-authored flow would otherwise convert to an agent with
+ * `JobArguments = {"input":""}` — works in SW, drops every bound input on
+ * `flow pack`, `solution pack` and `debug`. Mirroring SW here fills the gap.
+ *
+ * `resolveInputSchema` returns the agent's `inputSchema` for a given `source`,
+ * or `undefined` when it cannot be resolved. Best-effort by design: an
+ * unresolvable agent leaves its node as-is rather than failing the build.
+ *
+ * `onUnresolved` fires for a node this function could NOT hydrate, so callers
+ * can say so. Without it the empty-`JobArguments` bug this exists to fix comes
+ * back silently: the node keeps `agentInputVariables: []`, the converter emits
+ * the `{"input":""}` floor, and nothing in the output explains why. It does not
+ * fire for a node that needed nothing — an agent declaring no inputs, or one
+ * whose bindings the node already covers, is not a problem.
+ *
+ * Voice agents are hydrated but never reported: their inputs are authored on
+ * the node (`callContext`, explicit `agentInputVariables`) rather than bound
+ * from a schema, so an unresolved schema is the normal case and packaging
+ * already warns separately about a voice agent's embedded definition.
+ */
+export declare function hydrateInlineAgentInputVariables(nodes: InlineAgentNodeLike[], resolveInputSchema: (source: string) => Promise<unknown>, onReconcile?: (source: string, added: number) => void, onUnresolved?: (source: string, reason: "invalid-source" | "schema-unavailable") => void): Promise<void>;
 /**
  * Set `__packageIntent = "Publish"` on inline agent definitions in a
  * file-format workflow so the BPMN converter emits "content/" prefixed
@@ -18,3 +85,4 @@ export declare function isInlineAgentNodeType(type: string | undefined): boolean
  * Mutates `fileFormat` in place.
  */
 export declare function setPublishIntentOnInlineAgents(fileFormat: unknown): void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-flow",
-    "version": "1.201.0-preview.133",
+    "version": "1.202.0-preview.134",
     "description": "UiPath Flow tool implementation",
     "type": "module",
     "exports": {
@@ -25,13 +25,13 @@
     "author": "",
     "license": "ISC",
     "peerDependencies": {
-        "@uipath/filesystem": "1.201.0",
-        "@uipath/flow-converter": "^0.53.6",
-        "@uipath/flow-core": "^0.92.5",
-        "@uipath/flow-migrations": "^0.33.0",
-        "@uipath/flow-schema": "^0.57.6",
-        "@uipath/solutionpackager-tool-core": "1.201.0",
+        "@uipath/filesystem": "1.202.0",
+        "@uipath/flow-converter": "0.55.0-develop",
+        "@uipath/flow-core": "0.96.0-develop",
+        "@uipath/flow-migrations": "0.45.0-develop",
+        "@uipath/flow-schema": "0.57.4-develop",
+        "@uipath/solutionpackager-tool-core": "1.202.0",
         "@uipath/tool-agent": "^2.0.0"
     },
-    "gitHead": "7933378ad5276ac369900293a1447474dcec6826"
+    "gitHead": "a335728adbdb02f28308e4f55d8936d0b150444b"
 }

package/src/agent-input-encoding-utils.ts

@@ -0,0 +1,104 @@
+/**
+ * Encoding-agnostic readers for the inline-agent input encoding (MST-12020).
+ *
+ * flow-workbench writes inline-agent input names in one of two schemes, gated by its
+ * `services.agent-storage.nested-agent-input-schema` feature flag:
+ *  - FLAT (shipped default): one top-level `inputSchema` property per input, `__`-joined
+ *    (`script1__output__query`), prompts read `{{input.script1__output__query}}`.
+ *  - NESTED (flag on): a nested object tree whose auto-created container nodes carry
+ *    `x-uipath-container: true`, prompts read `{{input.script1.output.query}}` (the runtime
+ *    template engine treats `.` as navigation).
+ *
+ * The CLI must read BOTH — an agent.json is whatever the authoring canvas last wrote — so these
+ * helpers detect per file instead of consuming any flag. Detection is strictly the per-node
+ * container marker: an object property WITHOUT the marker is a user-declared whole-object input
+ * under either encoding and must be treated as one leaf, never unfolded.
+ *
+ * TODO: replace with flow-workbench's canonical helpers (`collectInlineAgentInputsFromAgent`,
+ * `decodeFlatName`, `getContainerChildProps`) once they are re-exported from
+ * `@uipath/flow-converter` — that package is the single source of truth for the encoding.
+ */
+
+/** Marker flow-workbench stamps on auto-created container nodes of a NESTED inputSchema. */
+export const SCHEMA_CONTAINER_MARKER = "x-uipath-container";
+
+/** One bindable input leaf of an agent `inputSchema`, in both name forms. */
+export interface AgentInputLeaf {
+    /** Flat `__`-joined name — what a flat prompt token / flat JobArgument uses. */
+    flatKey: string;
+    /** Canonical dotted path — what a nested prompt token navigates. */
+    path: string;
+    /** Declared `type` of the leaf node, when present. */
+    type?: string;
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+/** Children of a MARKED container node; `undefined` for leaves and declared whole-object inputs. */
+function containerChildren(prop: unknown): Record<string, unknown> | undefined {
+    if (!isRecord(prop)) return undefined;
+    if (prop[SCHEMA_CONTAINER_MARKER] !== true) return undefined;
+    const children = prop.properties;
+    return isRecord(children) ? children : undefined;
+}
+
+/** Canonical dotted form of an input name from either encoding (`a__b` and `a.b` → `a.b`). */
+export function canonicalAgentInputPath(name: string): string {
+    return name.split("__").join(".");
+}
+
+/**
+ * Enumerate the bindable input leaves of an agent `inputSchema`, descending MARKED containers
+ * (nested encoding) and passing flat / declared-object top-level keys through as single leaves.
+ * Returns `[]` for an absent/empty/malformed schema.
+ */
+export function collectAgentInputLeaves(
+    inputSchema: unknown,
+): AgentInputLeaf[] {
+    const properties = isRecord(inputSchema)
+        ? inputSchema.properties
+        : undefined;
+    if (!isRecord(properties)) return [];
+
+    const leaves: AgentInputLeaf[] = [];
+    const walk = (prop: unknown, segments: string[]): void => {
+        const children = containerChildren(prop);
+        if (!children) {
+            // Flat keys already carry their whole path in one segment; keep the
+            // stored spelling for flatKey and canonicalize for the dotted path.
+            const flatKey = segments.join("__");
+            leaves.push({
+                flatKey,
+                path: canonicalAgentInputPath(segments.join(".")),
+                type:
+                    isRecord(prop) && typeof prop.type === "string"
+                        ? prop.type
+                        : undefined,
+            });
+            return;
+        }
+        for (const [key, child] of Object.entries(children)) {
+            walk(child, [...segments, key]);
+        }
+    };
+    for (const [key, prop] of Object.entries(properties)) {
+        walk(prop, [key]);
+    }
+    return leaves;
+}
+
+/**
+ * Source binding expression for one input leaf — the inverse of flow-workbench's encode:
+ * a `metadata`-rooted path binds `$metadata.*`; everything else binds `$vars.*`.
+ */
+export function leafToBinding(leaf: AgentInputLeaf): string {
+    const segments = leaf.path.split(".");
+    if (segments[0] === "metadata") {
+        // A whole-object `metadata` leaf (unmarked object) has no trailing
+        // segments — bind the root `$metadata`, not an invalid `$metadata.`.
+        const rest = segments.slice(1).join(".");
+        return rest ? `=$metadata.${rest}` : "=$metadata";
+    }
+    return `=$vars.${leaf.path}`;
+}

package/src/agents.ts

@@ -1,3 +1,7 @@
+import {
+    healResourceInputEncoding,
+    normalizeAgentInputEncoding,
+} from "@uipath/flow-converter";
 import type {
     IFileSystem,
     IToolLogger,
@@ -16,7 +20,9 @@ export interface InlineAgentContract {
 
 /**
  * Build the execution contract for one inline agent with the same migration,
- * validation, and binding pipeline used by normal solution packaging.
+ * validation, and binding pipeline used by normal solution packaging. The
+ * returned `agentJson` is healed to the flat input encoding (MST-12020) — see
+ * {@link healAgentInputEncoding}.
  */
 export async function buildInlineAgentContract(config: {
     fileSystem: IFileSystem;
@@ -30,7 +36,9 @@ export async function buildInlineAgentContract(config: {
     });
 
     return {
-        agentJson: built.agent as Record<string, unknown>,
+        agentJson: healAgentInputEncoding(
+            built.agent as Record<string, unknown>,
+        ),
         bindingsJson: {
             version: built.bindings.version,
             resources: built.bindings.resources as unknown as Record<
@@ -41,6 +49,37 @@ export async function buildInlineAgentContract(config: {
     };
 }
 
+/**
+ * Normalize a built inline-agent contract to the FLAT input encoding (MST-12020) —
+ * the one heal every packaging path shares.
+ *
+ * The sidecar `agent.json` is whatever the authoring canvas last wrote: flat `__`
+ * names, or — behind flow-workbench's `nested-agent-input-schema` flag — a nested
+ * `x-uipath-container` tree with dotted prompt tokens. Flattens both halves: prompts
+ * + `inputSchema` via the agent heal, and each embedded resource's `argumentPath`
+ * via the resource heal. Applied by `buildInlineAgentContract` (flow-tool's
+ * `flow pack`/`publish`) and by `processAgents` (solution packaging). Defaults to
+ * 'flat', idempotent.
+ */
+function healAgentInputEncoding(
+    agent: Record<string, unknown>,
+): Record<string, unknown> {
+    const normalized = normalizeAgentInputEncoding(agent);
+    const rawResources = normalized.resources;
+    const resources = Array.isArray(rawResources)
+        ? rawResources.map((resource) =>
+              resource &&
+              typeof resource === "object" &&
+              !Array.isArray(resource)
+                  ? healResourceInputEncoding(
+                        resource as Record<string, unknown>,
+                    )
+                  : resource,
+          )
+        : rawResources;
+    return { ...normalized, resources };
+}
+
 /**
  * Build every root-level agent directory into the content folder and merge
  * their binding resources. Returns each built agent.json keyed by its
@@ -77,8 +116,18 @@ export const processAgents = async (
             outputPath: outputDir,
             logger,
         });
+        // buildAgent wrote the sidecar's encoding verbatim; normalize the deploy
+        // artifact to flat (MST-12020), matching `flow pack` / `publish`.
+        let agentJson = result.agent as Record<string, unknown>;
+        if (agentJson) {
+            agentJson = healAgentInputEncoding(agentJson);
+            await fileSystem.writeFile(
+                Path.join(outputDir, "agent.json"),
+                JSON.stringify(agentJson, null, 2),
+            );
+        }
         agentResults.push(result);
-        builtAgents.set(entry, result.agent as Record<string, unknown>);
+        builtAgents.set(entry, agentJson);
     }
 
     const agentBindingResources = agentResults.flatMap(toBindingsResources);

package/src/flow-tool.ts

@@ -40,6 +40,7 @@ import { ensureProcessBindings } from "./ensure-process-bindings.js";
 import { replaceExporterVersion } from "./exporter-version.js";
 import { readFlowWorkflow } from "./flow-io.js";
 import {
+    hydrateInlineAgentInputVariables,
     isInlineAgentNodeType,
     readInlineAgentSource,
     setPublishIntentOnInlineAgents,
@@ -273,6 +274,19 @@ export class FlowTool extends ProjectTool {
             return;
         }
 
+        // Reconcile each inline agent's `agentInputVariables` from its
+        // agent.json `inputSchema` before conversion. Studio-Web-authored
+        // flows write the node with `agentInputVariables: []` (SW assembles
+        // them in memory), and the converter derives `JobArguments` from that
+        // node array — so without this the agent packs with
+        // `JobArguments = {"input":""}` and every bound input is dropped
+        // (UV-15890 / UV-15979). Mirrors the debug path.
+        await this.hydrateInlineAgentInputs(
+            workflow,
+            builtAgents,
+            contentFolder,
+        );
+
         // Convert .flow to BPMN from the resolved file format, so any $ref
         // content is inlined before the converter sees it.
         // For pack/publish, set __packageIntent = "Publish" on inline agent
@@ -459,6 +473,45 @@ export class FlowTool extends ProjectTool {
         return voiceAgents;
     }
 
+    /**
+     * Reconcile each inline-agent node's `agentInputVariables` from its
+     * agent's `inputSchema` before conversion. Reads the schema from the
+     * already-built agent (`builtAgents`) first, falling back to an
+     * `agent.json` copied under `content/<source>/`. Mutates `workflow.nodes`
+     * in place; best-effort, so a missing/unreadable agent leaves the node
+     * as-is.
+     */
+    private async hydrateInlineAgentInputs(
+        workflow: Workflow,
+        builtAgents: ReadonlyMap<string, Record<string, unknown>>,
+        contentFolder: string,
+    ): Promise<void> {
+        const nodes = (workflow.nodes ?? []) as Array<{
+            type?: string;
+            inputs?: Record<string, unknown>;
+            model?: Record<string, unknown>;
+        }>;
+        await hydrateInlineAgentInputVariables(
+            nodes,
+            async (source) => {
+                const agent =
+                    builtAgents.get(source) ??
+                    (await this.readCopiedAgentJson(contentFolder, source));
+                return agent?.inputSchema;
+            },
+            (source, added) =>
+                this.logger.info(
+                    `Reconciled ${added} inline-agent input(s) for "${source}" from agent.json inputSchema`,
+                ),
+            (source, reason) =>
+                this.logger.warn(
+                    reason === "invalid-source"
+                        ? `Inline agent "${source}" is not a bare project-id folder, so its inputs were not reconciled and packaging skips it — the agent would ship with no bound inputs.`
+                        : `Could not read an inputSchema for inline agent "${source}", so its inputs were not reconciled — the agent would ship with no bound inputs. Check that ${source}/agent.json exists and parses.`,
+                ),
+        );
+    }
+
     /** Read an `agent.json` copied in without going through `buildAgent`. */
     private async readCopiedAgentJson(
         contentFolder: string,

package/src/index.ts

@@ -8,6 +8,13 @@
 import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
 import { FlowToolFactory } from "./flow-tool-factory.js";
 
+export {
+    type AgentInputLeaf,
+    canonicalAgentInputPath,
+    collectAgentInputLeaves,
+    leafToBinding,
+    SCHEMA_CONTAINER_MARKER,
+} from "./agent-input-encoding-utils.js";
 export {
     buildInlineAgentContract,
     type InlineAgentContract,
@@ -24,8 +31,11 @@ export {
 export { FlowTool } from "./flow-tool.js";
 export { FlowToolFactory } from "./flow-tool-factory.js";
 export {
+    type AgentInputVariable,
+    hydrateInlineAgentInputVariables,
     isInlineAgentNodeType,
     readInlineAgentSource,
+    reconcileInlineAgentInputVariables,
     setPublishIntentOnInlineAgents,
 } from "./inline-agent-utils.js";
 export { operateRuntimeOptions } from "./operate-runtime-options.js";

package/src/inline-agent-utils.ts

@@ -1,4 +1,9 @@
-import { isAgentNodeType } from "@uipath/flow-schema";
+import { isAgentNodeType, isVoiceAgentNodeType } from "@uipath/flow-schema";
+import {
+    canonicalAgentInputPath,
+    collectAgentInputLeaves,
+    leafToBinding,
+} from "./agent-input-encoding-utils.js";
 
 /**
  * Resolve the inline-agent's projectId UUID from a flow node. Falls back to
@@ -29,6 +34,147 @@ export function isInlineAgentNodeType(type: string | undefined): boolean {
     return isAgentNodeType(type);
 }
 
+/** One flow-node `agentInputVariables[]` entry. */
+export interface AgentInputVariable {
+    id?: string;
+    type?: string;
+    binding?: string;
+    description?: string;
+}
+
+/**
+ * Reconcile a node's existing `agentInputVariables` against an agent's
+ * `inputSchema` — the input contract the runtime actually binds.
+ *
+ * Adds a derived entry for every input leaf the node is missing and preserves
+ * every entry the node already declares, so a custom or divergent binding is
+ * never clobbered. Leaves come from {@link collectAgentInputLeaves}, so a
+ * nested schema descends its marked containers rather than being read as one
+ * opaque top-level key.
+ *
+ * Comparison is on the canonical dotted path, so a node that declares the
+ * nested spelling (`a.b`) is not re-added under the flat one (`a__b`). The
+ * derived id is always the FLAT spelling: the packager heals the shipped
+ * agent.json prompts and schema to the flat encoding, and the converter emits
+ * each id verbatim as a JobArgument name, so flat ids are what match the
+ * healed `{{input.<flat>}}` tokens for both schema encodings.
+ *
+ * Returns the reconciled list plus how many entries were added; when nothing
+ * is missing (or the schema is empty) returns the original array unchanged so
+ * callers can skip a spurious mutation.
+ */
+export function reconcileInlineAgentInputVariables(
+    existing: AgentInputVariable[],
+    inputSchema: unknown,
+): { variables: AgentInputVariable[]; added: number } {
+    const leaves = collectAgentInputLeaves(inputSchema);
+    if (leaves.length === 0) {
+        return { variables: existing, added: 0 };
+    }
+    const existingPaths = new Set(
+        existing
+            .map((e) => e.id)
+            .filter((id): id is string => typeof id === "string")
+            .map(canonicalAgentInputPath),
+    );
+    const additions = leaves
+        .filter((leaf) => !existingPaths.has(leaf.path))
+        .map((leaf) => {
+            const binding = leafToBinding(leaf);
+            return {
+                id: leaf.flatKey,
+                type: leaf.type ?? "string",
+                binding,
+                // binding is "=$vars.X" / "=$metadata.X"; drop the "="
+                description: `Bound from ${binding.slice(1)}`,
+            };
+        });
+    if (additions.length === 0) {
+        return { variables: existing, added: 0 };
+    }
+    return { variables: [...existing, ...additions], added: additions.length };
+}
+
+/** Minimal shape of a flow node needed to hydrate inline-agent inputs. */
+interface InlineAgentNodeLike {
+    type?: string;
+    inputs?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+}
+
+/**
+ * Reconcile every inline-agent node's `agentInputVariables` against its
+ * agent's `inputSchema` before BPMN conversion. Mutates `nodes` in place.
+ *
+ * Studio Web keeps the input binding in the agent's `inputSchema` and rebuilds
+ * the node's `agentInputVariables` from it in memory on load; the `.flow` it
+ * writes carries an empty `agentInputVariables`. The converter derives the
+ * agent's `JobArguments` from `agentInputVariables` and never reads
+ * `agent.json`, so an SW-authored flow would otherwise convert to an agent with
+ * `JobArguments = {"input":""}` — works in SW, drops every bound input on
+ * `flow pack`, `solution pack` and `debug`. Mirroring SW here fills the gap.
+ *
+ * `resolveInputSchema` returns the agent's `inputSchema` for a given `source`,
+ * or `undefined` when it cannot be resolved. Best-effort by design: an
+ * unresolvable agent leaves its node as-is rather than failing the build.
+ *
+ * `onUnresolved` fires for a node this function could NOT hydrate, so callers
+ * can say so. Without it the empty-`JobArguments` bug this exists to fix comes
+ * back silently: the node keeps `agentInputVariables: []`, the converter emits
+ * the `{"input":""}` floor, and nothing in the output explains why. It does not
+ * fire for a node that needed nothing — an agent declaring no inputs, or one
+ * whose bindings the node already covers, is not a problem.
+ *
+ * Voice agents are hydrated but never reported: their inputs are authored on
+ * the node (`callContext`, explicit `agentInputVariables`) rather than bound
+ * from a schema, so an unresolved schema is the normal case and packaging
+ * already warns separately about a voice agent's embedded definition.
+ */
+export async function hydrateInlineAgentInputVariables(
+    nodes: InlineAgentNodeLike[],
+    resolveInputSchema: (source: string) => Promise<unknown>,
+    onReconcile?: (source: string, added: number) => void,
+    onUnresolved?: (
+        source: string,
+        reason: "invalid-source" | "schema-unavailable",
+    ) => void,
+): Promise<void> {
+    for (const node of nodes) {
+        if (!isInlineAgentNodeType(node.type)) continue;
+        const source = readInlineAgentSource(node);
+        if (!source) continue;
+        // Same guard as inline-agent packaging: a `source` is a bare UUID
+        // folder name. Skip anything with `/`, `\`, or `.` so a traversing or
+        // divergent source cannot read an agent.json outside the packageable
+        // folder — packaging skips these too, so reconciling them would mutate
+        // inputs for an agent that will not ship.
+        const reportable = !isVoiceAgentNodeType(node.type);
+        if (/[/\\.]/.test(source)) {
+            if (reportable) onUnresolved?.(source, "invalid-source");
+            continue;
+        }
+
+        const inputSchema = await resolveInputSchema(source);
+        if (inputSchema === undefined) {
+            if (reportable) onUnresolved?.(source, "schema-unavailable");
+            continue;
+        }
+
+        const existing = Array.isArray(node.inputs?.agentInputVariables)
+            ? (node.inputs.agentInputVariables as AgentInputVariable[])
+            : [];
+        const { variables, added } = reconcileInlineAgentInputVariables(
+            existing,
+            inputSchema,
+        );
+        if (added === 0) continue;
+
+        if (!node.inputs) node.inputs = {};
+        node.inputs.agentInputVariables = variables;
+        onReconcile?.(source, added);
+    }
+}
+
 /**
  * Set `__packageIntent = "Publish"` on inline agent definitions in a
  * file-format workflow so the BPMN converter emits "content/" prefixed