@uipath/maestro-builder-sdk 6.16.3 → 6.16.5

package/dist/check.js

@@ -3206,14 +3206,14 @@ function checkInlineAgent(step, inputs, diags, opts = {}) {
             : `inputs: { ${undeclared[0]}: input('${undeclared[0]}') }`);
     }
     // Direction 3: an input bound to a COMPUTED EXPRESSION rather than to one
-    // reference. The platform names an agent's arguments by flat-mangling the
-    // references it finds in the node's prompts, so an expression spanning zero or
-    // several references has no single argument — and therefore no name a
-    // `{{input.<x>}}` token could address. Its data still reaches the agent (the
-    // platform derives one argument per reference inside the expression), but not
-    // under a name the prompt can use, so the placeholder would reach the model as
-    // literal text. An error rather than a warning, and for the same reason
-    // `INLINE_AGENT_UNDECLARED_PLACEHOLDER` is one: the value never arrives.
+    // reference. The platform names each of an agent's arguments after the
+    // reference path it is bound to (the shell node's `agentInputVariables`), so
+    // an expression spanning zero or several references has no single argument —
+    // and therefore no name a `{{input.<x>}}` token could address. The compiler
+    // declares no argument for it, so its value does not reach the agent, and the
+    // placeholder reaches the model as literal text. An error rather than a
+    // warning, and for the same reason `INLINE_AGENT_UNDECLARED_PLACEHOLDER` is
+    // one: the value never arrives.
     for (const [name, val] of Object.entries(inputs?.inputs ?? {})) {
         if (!(val instanceof Expr) || val.literal)
             continue;
@@ -3223,11 +3223,10 @@ function checkInlineAgent(step, inputs, diags, opts = {}) {
             continue;
         at('INLINE_AGENT_COMPOSITE_INPUT', `Inline agent step "${step}"'s input \`${name}\` is bound to a computed expression `
             + `(\`${val.js.length > 60 ? `${val.js.slice(0, 60)}…` : val.js}\`), and a prompt references it as `
-            + `\`{{input.${name}}}\`. The platform does not send the agent the names you declared: it scans the `
-            + `node's prompts for variable references and names each argument after the REFERENCE PATH `
-            + `(\`$vars.a.output.b\` → \`a__output__b\`). A computed expression is not one reference, so it has no `
-            + `single argument to name and the placeholder cannot be substituted — it would reach the model as `
-            + `that literal text.`, `compute it in a script step first, then bind the step's output: `
+            + `\`{{input.${name}}}\`. The platform does not send the agent the names you declared: it names each `
+            + `argument after the REFERENCE PATH the input is bound to (\`$vars.a.output.b\` → \`a__output__b\`). `
+            + `A computed expression is not one reference, so it gets no argument: its value does not reach the `
+            + `agent, and the placeholder reaches the model as that literal text.`, `compute it in a script step first, then bind the step's output: `
             + `.step('${name}Value', script({ code: 'return …;' })) … inputs: { ${name}: out('${name}Value') }`);
     }
     // A step id containing `__` makes the flat name AMBIGUOUS on the platform: the

package/dist/core/actions.d.ts

@@ -699,15 +699,24 @@ export interface ConversationalAgentInputs {
      */
     settings: ConversationalAgentSettings;
     /**
-     * Whether the agent's reply CLOSES the exchange. The platform's legacy
-     * default is to end it; pass `false` to keep it open for another turn.
+     * Whether the agent's reply CLOSES the exchange.
+     *
+     * @deprecated Has no effect and is not emitted. The platform retired the input:
+     * the conversational agent's v1.7 node migration removes it, and the converter
+     * always sends `conversationalService.endExchange = ''`. Wait-for-message and
+     * the end of the conversation close open exchanges.
      */
     endExchange?: boolean;
     /** Sampling temperature, 0–1. */
     temperature?: number;
     /** Max tokens in one response. */
     maxTokenPerResponse?: number;
-    /** The model's own context ceiling — informational. */
+    /**
+     * The model's own context ceiling.
+     *
+     * @deprecated Has no effect and is not emitted. Studio Web derives it from the
+     * selected model.
+     */
     modelMaxTokens?: number;
     /** How many tool-calling rounds one turn may take, 1–100. */
     maxIterations?: number;
@@ -1407,20 +1416,19 @@ export interface InlineAgentInputs {
      * ```
      *
      * Why a placeholder rather than an interpolated expression: an inline agent is two
-     * artifacts, and its prompt exists in THREE dialects. You write one; the compiler
-     * emits the other two.
+     * artifacts, and its prompt exists in TWO dialects. You write one; the compiler
+     * emits the other into the `agent.json` sidecar. The `.flow` node carries no copy
+     * of the prompt: it is a shell, so Studio Web reads the sidecar.
      *
      *   1. yours          `{{input.claim}}`
-     *   2. the NODE's     `=js:$vars.prepare.output.claimRef`   ← what the platform SCANS
-     *   3. the AGENT.JSON `{{input.prepare__output__claimRef}}` ← what the runtime SENDS
+     *   2. the AGENT.JSON `{{input.prepare__output__claimRef}}` ← what the runtime SENDS
      *
-     * The third exists because the platform does not send an agent the names you
-     * declared: it scans the node's prompts for `$vars.*` references and names each
-     * argument after the reference PATH, `__`-joined. For a flow input the two
-     * coincide (`$vars.notes` → `notes`); for a step output they do not, and a sidecar
-     * still saying `{{input.claim}}` templates against a key that is not there — the
-     * literal text reaches the model. See the inline-agent node reference (`website/reference/inline-agent.md`)
-     * §"The three prompt DIALECTS".
+     * The second exists because the platform does not send an agent the names you
+     * declared: it names each argument after the bound reference PATH, `__`-joined.
+     * For a flow input the two coincide (`$vars.notes` → `notes`); for a step output
+     * they do not, and a sidecar still saying `{{input.claim}}` templates against a key
+     * that is not there — the literal text reaches the model. See the inline-agent
+     * node reference (`website/reference/inline-agent.md`) §"The prompt dialects".
      *
      * **The answer's shape is `returns`, not the prompt.** `returns` becomes the node's
      * `agentOutputVariables` and the `agent.json` `outputSchema` — what Studio Web's
@@ -1506,7 +1514,13 @@ export interface InlineAgentInputs {
     temperature?: number;
     /** Max tokens in one response, 0–16384. */
     maxTokenPerResponse?: number;
-    /** The model's own context ceiling — informational, e.g. `128000`. */
+    /**
+     * The model's own context ceiling, e.g. `128000`.
+     *
+     * @deprecated Has no effect and is not emitted. Studio Web derives it from the
+     * selected model each time the agent is opened, and the sidecar has no field
+     * for it.
+     */
     modelMaxTokens?: number;
     /** How many tool-calling rounds the agent may take, 1–100. */
     maxIterations?: number;

package/dist/decompile-cli.js

@@ -19,7 +19,7 @@
  */
 import { reportResult } from './cli-result.js';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { defaultSourceOut, workDirBeside, writeSource } from './workdir.js';
 import { decompile } from './decompile.js';
 import { resolveFlowRefs } from './ref-resolve.js';
@@ -65,6 +65,15 @@ export function run(argv) {
         // writable band) go to stderr, where the agent running the brownfield loop
         // reads them before compile refuses.
         warn: (message) => console.error(`flow-decompile: warning: ${message}`),
+        // A shell agent node's prompts live in `<source>/agent.json` beside the .flow.
+        readSidecar: (relativePath) => {
+            try {
+                return readFileSync(join(dirname(resolve(pos)), relativePath), 'utf8');
+            }
+            catch {
+                return undefined;
+            }
+        },
     });
     const out = opt(argv, '-o') ?? defaultSourceOut(`${baseName(flow)}.flow.ts`);
     writeSource(out, ts);

package/dist/decompile.d.ts

@@ -133,6 +133,17 @@ export interface DecompileOptions {
      * `compile` will refuse it). The CLI prints these on stderr.
      */
     warn?: (message: string) => void;
+    /**
+     * Reads a file of the flow's project, by path relative to the `.flow`'s
+     * directory; returns `undefined` when it is absent. Used for an agent node
+     * that is a SHELL (no prompts on the node, the shape compile writes since
+     * #927): its prompts, model and voice settings are read back from
+     * `<source>/agent.json`. The sidecar speaks flat input names
+     * (`{{input.start__output__notes}}`), so the recovered source declares its
+     * inputs under those names — the same flow, not the same spelling. Without a
+     * reader, a shell agent decompiles with empty prompts and a warning.
+     */
+    readSidecar?: (relativePath: string) => string | undefined;
 }
 export declare function decompile(flow: FlowFile, options?: DecompileOptions): string;
 export {};

package/dist/decompile.js

@@ -79,6 +79,8 @@ let runStrict = false;
 /** `DecompileOptions.warn` for the current run, and the messages already sent to it (one line per finding). */
 let runWarn;
 let runWarned = new Set();
+/** `DecompileOptions.readSidecar` for the current run. */
+let runReadSidecar;
 function warnOnce(message) {
     if (runWarned.has(message))
         return;
@@ -1021,6 +1023,84 @@ function connectorObjectName(configuration) {
  * Returns `undefined` when the node is not one of them, so the caller can fall
  * through to the next arm.
  */
+/** The `maxIterations` Studio Web writes into every inline agent's `agent.json` (flow-workbench `getDefaultAgentContent()`). */
+const STUDIO_WEB_DEFAULT_MAX_ITERATIONS = 25;
+/**
+ * The agent configuration a SHELL agent node keeps in its sidecar, read from
+ * `<source>/agent.json` in the node's own input names: the prompts, the model,
+ * the run settings (`temperature`, `maxTokenPerResponse`, `maxIterations`,
+ * `mode`), the `guardrails` and (voice) the `voice` settings. Empty when the
+ * node carries prompts itself (an embedded node, e.g. a `.flow` saved by Studio
+ * Web with the self-contained flag on), or when no sidecar can be read.
+ *
+ * A run setting equal to the default a sidecar writer fills in (`temperature`
+ * 0, `maxTokens` 16384, `mode` `'standard'`) is not recovered: recompiling
+ * without it writes the same sidecar, and recovering it would add an argument
+ * the author never wrote to every agent. `mode: 'standard'` is the exception on
+ * a 1.3 node, where naming it is what selected that definition. The same goes
+ * for the inline agent's `maxIterations` 25: the SDK omits it when unset, but
+ * Studio Web always writes it (its `getDefaultAgentContent()` default), so
+ * every Studio Web-saved agent would otherwise decompile with `maxIterations: 25`.
+ */
+function sidecarAgentInputs(node) {
+    const inputs = (node.inputs ?? {});
+    if (typeof inputs.systemPrompt === 'string' || typeof inputs.userPrompt === 'string')
+        return {};
+    const source = unwrapSource(inputs.source);
+    if (!source)
+        return {};
+    const path = `${source}/agent.json`;
+    const raw = runReadSidecar?.(path);
+    if (raw === undefined) {
+        warnOnce(`agent step "${node.id}" carries no prompts and ${path} was not found beside the .flow, `
+            + 'so its prompts, model and run settings decompile empty. Keep <source>/agent.json beside the .flow '
+            + '(download the whole project, not just the .flow).');
+        return {};
+    }
+    let agent;
+    try {
+        agent = JSON.parse(raw);
+    }
+    catch {
+        warnOnce(`agent step "${node.id}": ${path} is not valid JSON, so its prompts, model and run settings decompile empty.`);
+        return {};
+    }
+    const messages = (Array.isArray(agent?.messages) ? agent.messages : []);
+    const content = (role) => {
+        const c = messages.find((m) => m.role === role)?.content;
+        return typeof c === 'string' ? c : undefined;
+    };
+    const settings = (agent?.settings ?? {});
+    const system = content('system');
+    const user = content('user');
+    const isVoice = node.type === T.voiceAgent;
+    const numberUnless = (v, dflt) => typeof v === 'number' && v !== dflt ? v : undefined;
+    // The voice agent's temperature and token cap live in `settings.voice`, not here.
+    const temperature = isVoice ? undefined : numberUnless(settings.temperature, 0);
+    const maxTokenPerResponse = isVoice ? undefined : numberUnless(settings.maxTokens, 16384);
+    // Studio Web's default for the inline agent; the other families keep any value.
+    const maxIterations = node.type === T.inlineAgent
+        ? numberUnless(settings.maxIterations, STUDIO_WEB_DEFAULT_MAX_ITERATIONS)
+        : typeof settings.maxIterations === 'number' ? settings.maxIterations : undefined;
+    // `mode` is a harness choice on the inline agent only; the conversational and
+    // voice sidecars always carry their family's fixed value. Naming it is also
+    // what selects the 1.3 definition, so on a 1.3 node even `'standard'` was the
+    // author's.
+    const mode = node.type === T.inlineAgent && typeof settings.mode === 'string'
+        && (settings.mode !== 'standard' || node.typeVersion === '1.3')
+        ? settings.mode : undefined;
+    return {
+        ...(system === undefined ? {} : { systemPrompt: system }),
+        ...(user === undefined ? {} : { userPrompt: user }),
+        ...(typeof settings.model === 'string' ? { model: settings.model } : {}),
+        ...(temperature === undefined ? {} : { temperature }),
+        ...(maxTokenPerResponse === undefined ? {} : { maxTokenPerResponse }),
+        ...(maxIterations === undefined ? {} : { maxIterations }),
+        ...(mode === undefined ? {} : { mode }),
+        ...(Array.isArray(agent?.guardrails) && agent.guardrails.length > 0 ? { guardrails: agent.guardrails } : {}),
+        ...(isVoice && settings.voice && typeof settings.voice === 'object' ? { voice: settings.voice } : {}),
+    };
+}
 /**
  * An AGENT and its attached resources — the inline autonomous agent, the
  * conversational agent, and the voice agent.
@@ -1038,7 +1118,8 @@ function connectorObjectName(configuration) {
  * preserved exactly; only these logical names change.)
  */
 function emitAgentCluster(node, imp, inputNames, graph) {
-    const i = (node.inputs ?? {});
+    // A key on the node wins over the sidecar's copy of it.
+    const i = { ...sidecarAgentInputs(node), ...(node.inputs ?? {}) };
     const plain = (v) => {
         const raw = unwrapSource(v);
         return raw === undefined || raw === '' ? undefined : raw;
@@ -1047,10 +1128,12 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         const raw = unwrapPlain(v);
         return typeof raw === 'number' ? String(raw) : undefined;
     };
-    // Prompts: invert `renderInlineAgentPrompt`. It replaced each
-    // `{{input.<name>}}` with that input's rendered binding, so the bindings in
-    // `agentInputVariables` are exactly what to put back — longest first, so a
-    // shorter binding cannot eat a longer one's prefix.
+    // Prompts. A sidecar prompt already speaks `{{input.<flatName>}}`, so this
+    // leaves it alone. An EMBEDDED node's prompt (Studio Web with the
+    // self-contained flag on, or an SDK before #927) carries each input as its
+    // rendered binding instead; the bindings in `agentInputVariables` are exactly
+    // what to put back — longest first, so a shorter binding cannot eat a longer
+    // one's prefix.
     const vars = (Array.isArray(i.agentInputVariables) ? i.agentInputVariables : []);
     const refs = vars
         .filter((v) => typeof v.id === 'string' && typeof v.binding === 'string')
@@ -1312,10 +1395,8 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             // `settings` is required on ConversationalAgentInputs, so an empty one
             // stays as `{}`, which check then reports as CONV_AGENT_NO_TURN.
             ['settings', settingsSrc || '{}'],
-            ['endExchange', unwrapPlain(i.endExchange) === false ? 'false' : undefined],
             ['temperature', num(i.temperature)],
             ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
-            ['modelMaxTokens', num(i.modelMaxTokens)],
             ['maxIterations', num(i.maxIterations)],
             ['guardrails', guardrails],
             ['source', str(plain(i.source) ?? '')],
@@ -1329,7 +1410,6 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         ['returns', returns],
         ['temperature', num(i.temperature)],
         ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
-        ['modelMaxTokens', num(i.modelMaxTokens)],
         ['maxIterations', num(i.maxIterations)],
         ['mode', plain(i.mode) !== undefined ? str(plain(i.mode)) : undefined],
         ['guardrails', guardrails],
@@ -2616,6 +2696,7 @@ export function decompile(flow, options = {}) {
     const importSpecifier = options.importSpecifier ?? './flow-sdk.js';
     runStrict = options.bestEffort === false;
     runWarn = options.warn;
+    runReadSidecar = options.readSidecar;
     runWarned = new Set();
     runDefPairs = new Set((flow.definitions ?? [])
         .filter((d) => typeof d?.nodeType === 'string' && typeof d?.version === 'string')

package/dist/serialize.js

@@ -2204,10 +2204,9 @@ function inlineAgentDef(spec) {
 /**
  * Classify a RENDERED input value (the output of {@link renderValue}).
  *
- * The `=js:` test is the same one `renderInlineAgentPrompt` uses, deliberately:
- * both halves of the emission must agree about what is an expression, and a
- * literal string that happens to begin with `=js:` is already treated as one
- * there.
+ * A rendered value is an expression exactly when it starts with `=js:` — the
+ * same test the rest of the serializer applies, so a literal string that
+ * happens to begin with `=js:` is treated as one everywhere.
  */
 function classifyAgentInput(rendered) {
     if (typeof rendered !== 'string' || !rendered.startsWith('=js:')) {
@@ -2471,40 +2470,6 @@ function promptTokens(content) {
         tokens.push({ type: 'simpleText', rawString: content.slice(last) });
     return tokens.length ? tokens : [{ type: 'simpleText', rawString: content }];
 }
-/**
- * Render an inline agent's prompt for the NODE, which speaks a different dialect
- * from the `agent.json`.
- *
- * The author writes `{{input.<name>}}`, which is what the agent's own template
- * language uses and what goes into `agent.json` verbatim. The node's copy has to
- * carry the FLOW expression instead: flow-v1's `preDeriveAgentInputDefinitions`
- * builds the deployed input list by scanning the node's prompts for `$vars.*`
- * references, and — when its caller prunes — drops any `agentInputVariables` entry no
- * such reference points at. A prompt with no references can therefore deploy an agent
- * that receives nothing, with the authored list sitting in the file unused.
- *
- * So each placeholder becomes the rendered binding of that input, `=js:`-prefixed the
- * way an embedded expression is read. One caveat that comes with that encoding:
- * an embedded run has no terminator, so it is read to
- * end-of-line and then backed off token by token until a prefix evaluates. That
- * resolves `"Notes: =js:$vars.notes and then some"` correctly, but a placeholder
- * followed by more text on the same line is doing more work than one at end of line.
- *
- * A placeholder naming something `inputs` does not declare is left ALONE rather than
- * silently deleted: it reaches the model as literal `{{input.x}}`, which is visible,
- * and `check` names it.
- */
-function renderInlineAgentPrompt(template, inputs, rename) {
-    return template.replace(INPUT_PLACEHOLDER, (whole, name) => {
-        if (!Object.prototype.hasOwnProperty.call(inputs, name))
-            return whole;
-        const rendered = renderValue(inputs[name], rename);
-        // A literal binding needs no expression at all — inline the value.
-        if (typeof rendered === 'string' && rendered.startsWith('=js:'))
-            return rendered;
-        return String(rendered);
-    });
-}
 /**
  * The parts every `uipath.ixp.*` definition shares, bundled verbatim from
  * `uip maestro flow registry get` (2026-07-31, after `registry pull --force`).
@@ -5136,29 +5101,35 @@ export function serialize(built, opts = {}) {
             // What the PLATFORM will call each of these — computed once and shared by
             // the descriptor array below and the sidecar. See `agentInputPlan`.
             const plan = agentInputPlan(nodeInputs, scope.rename);
+            // A SHELL node (#927): the prompts and the model live only in the
+            // `<source>/agent.json` sidecar written below, never on the node. Studio
+            // Web decides which copy wins by `hasEmbeddedAgentContent`
+            // (@uipath/flow-schema): any `systemPrompt`/`userPrompt` string on the node
+            // makes the `.flow` authoritative and the sidecar is skipped, so a node copy
+            // shadowed the sidecar and lost the input tokens and the tool configuration
+            // on the first save. With no prompt strings the converter also keeps the
+            // `agentInputVariables` below as written (`canPruneAgentInputs` is false),
+            // and `uip maestro flow debug` reconciles them against the sidecar's
+            // `inputSchema`.
+            //
+            // The run settings (`mode`, `temperature`, `maxTokenPerResponse`,
+            // `maxIterations`, `guardrails`) live in the sidecar too. The node keeps
+            // exactly the keys Studio Web's own strip keeps (`toAgentShellInputs`,
+            // @uipath/flow-schema): anything else is discarded on hydrate, and while
+            // present it makes Studio Web "trust the .flow" when the sidecar folder is
+            // missing (`flowNodeHasRealInputs`), flushing a prompt-less agent.json.
+            // `modelMaxTokens` is written nowhere: the designer derives it from the
+            // selected model.
             node.inputs = {
                 source,
-                // The NODE's dialect: `{{input.x}}` → the flow expression, so flow-v1's
-                // input-derivation pre-pass can see the reference. See
-                // `renderInlineAgentPrompt`.
-                systemPrompt: renderInlineAgentPrompt(s.systemPrompt, nodeInputs, scope.rename),
-                userPrompt: renderInlineAgentPrompt(s.userPrompt, nodeInputs, scope.rename),
-                model: s.model,
-                ...(s.mode === undefined ? {} : { mode: s.mode }),
-                ...(s.temperature === undefined ? {} : { temperature: s.temperature }),
-                ...(s.maxTokenPerResponse === undefined ? {} : { maxTokenPerResponse: s.maxTokenPerResponse }),
-                ...(s.modelMaxTokens === undefined ? {} : { modelMaxTokens: s.modelMaxTokens }),
-                ...(s.maxIterations === undefined ? {} : { maxIterations: s.maxIterations }),
-                ...(s.guardrails === undefined ? {} : { guardrails: s.guardrails }),
                 // The two DESCRIPTOR ARRAYS. `agentInputVariables` entries carry the
                 // binding expression; `agentOutputVariables` entries are name + type only,
                 // and the runtime's structured final call fills exactly these keys.
                 //
-                // `id` is the FLAT NAME, not the author's — the platform re-derives this
-                // array from the node's prompts and keeps a pre-existing entry only when
-                // its id already IS a flatName (`deriveAgentInputVariables:506-509`). One
-                // entry per flatName, so two logical names bound to the same reference
-                // claim one argument rather than two.
+                // `id` is the FLAT NAME, not the author's — the name the runtime's
+                // JobArguments are keyed by, and the key the CLI reconciles against the
+                // sidecar's `inputSchema`. One entry per flatName, so two logical names
+                // bound to the same reference claim one argument rather than two.
                 agentInputVariables: plan.refs.map((r) => ({
                     id: r.flatName,
                     type: 'string',
@@ -5727,19 +5698,15 @@ export function serialize(built, opts = {}) {
                 if (v !== undefined)
                     settings[key] = v;
             }
+            // A SHELL node, like the inline agent's (#927): exactly the keys
+            // `toAgentShellInputs` keeps. The system prompt, the model and the run
+            // settings live only in the sidecar (`metadata.isConversational` there is
+            // the family flag). `endExchange` is written nowhere: the platform retired
+            // it (the node's v1.7 migration drops it, and the converter always sends
+            // `conversationalService.endExchange = ''`).
             node.inputs = {
                 source,
-                systemPrompt: s.systemPrompt,
-                model: s.model,
-                // The family's own flag — every instance of this node IS conversational.
-                isConversational: true,
                 conversationalAgentSettings: settings,
-                ...(s.endExchange === undefined ? {} : { endExchange: s.endExchange }),
-                ...(s.temperature === undefined ? {} : { temperature: s.temperature }),
-                ...(s.maxTokenPerResponse === undefined ? {} : { maxTokenPerResponse: s.maxTokenPerResponse }),
-                ...(s.modelMaxTokens === undefined ? {} : { modelMaxTokens: s.modelMaxTokens }),
-                ...(s.maxIterations === undefined ? {} : { maxIterations: s.maxIterations }),
-                ...(s.guardrails === undefined ? {} : { guardrails: s.guardrails }),
             };
             scope.nodes.push(node);
             sidecars.push({
@@ -5797,15 +5764,16 @@ export function serialize(built, opts = {}) {
             delete node.model;
             const nodeInputs = s.inputs ?? {};
             const plan = agentInputPlan(nodeInputs, scope.rename);
+            // A SHELL node (#927): the system prompt and the `voice` settings live only
+            // in the sidecar's `messages` and `settings.voice`. On a voice node either
+            // one makes Studio Web treat the `.flow` as authoritative and skip the
+            // sidecar (`hasEmbeddedAgentContent`). `uip maestro flow debug` builds the
+            // voice agent from the sidecar (`packageInlineAgents`).
+            // The node keeps exactly the keys `toAgentShellInputs` keeps;
+            // `maxIterations` and `metadata.isConversational` are in the sidecar.
             node.inputs = {
                 source,
-                systemPrompt: renderInlineAgentPrompt(s.systemPrompt, nodeInputs, scope.rename),
                 callContext: renderValue(toExpr(s.callContext), scope.rename),
-                // The platform's own flag for this family — every voice agent IS
-                // conversational, and the definition declares the field.
-                isConversational: true,
-                ...(s.maxIterations === undefined ? {} : { maxIterations: s.maxIterations }),
-                ...(s.voice === undefined ? {} : { voice: { ...s.voice } }),
                 ...(plan.refs.length === 0 ? {} : {
                     agentInputVariables: plan.refs.map((r) => ({
                         id: r.flatName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.16.3",
+  "version": "6.16.5",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "c6b0cc7e26df31a2699ad9b67f3b5a9e2532bcd4"
+  "gitref": "b6731e22dc81fb2ca34f4463bc1785aaae16d174"
 }