@uipath/maestro-builder-sdk 6.41.2 → 6.43.0

package/dist/decompile.js

@@ -35,10 +35,7 @@ import { DEFAULT_TRIGGER_ID, Expr } from './core/expr.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { SUBFLOW_START_LABEL } from './core/subflow-start.js';
 import { commentText } from './core/comment-text.js';
-import { tsLiteral, tsNumber, tsText } from './core/ts-literal.js';
-import { ownEntry } from './core/own-entry.js';
-import { CONTEXT_INDEX_DEFAULTS, CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, contextIndexSlug, parseContextIndexType, } from './core/context-index.js';
-import { derivedContextSource, derivedEscalationSource, derivedResourceNodeId, derivedToolSource, } from './core/agent-resource-identity.js';
+import { tsKey as key, tsLiteral, tsNumber, tsObject as objLit, tsOptions as opts, tsText } from './core/ts-literal.js';
 import { wireExprBody } from './core/wire-expr.js';
 import { hasExits } from './core/step-ports.js';
 import { parseIxpProjectType } from './core/actions.js';
@@ -51,7 +48,6 @@ import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
 import { contributionPort, forwardFanOut } from './core/definition-handles.js';
 import { STICKY_NOTE_TYPE } from './core/definitionless-node-types.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
-import { formFieldRowLoss, formFieldRowLossMessage, formFieldSettingsSource, liftFormFieldSettings, sourceFormFieldType, } from './core/form-field-type.js';
 /**
  * The trigger id of the flow currently being decompiled, so a reference through a
  * RENAMED trigger is still recognized as `input('x')` rather than falling back to
@@ -263,12 +259,7 @@ const T = {
     triggerForm: 'core.trigger.form',
     triggerConversation: 'core.trigger.conversation',
     hitl: 'uipath.human-in-the-loop',
-    inlineAgent: 'uipath.agent.autonomous',
-    conversationalAgent: 'uipath.agent.conversational',
-    voiceAgent: 'uipath.agent.voice',
     triggerVoice: 'core.trigger.voice',
-    createOutgoingCall: 'uipath.conversational.voice.create-outgoing-call',
-    endCall: 'uipath.conversational.voice.end-call',
     decision: 'core.logic.decision',
     switch: 'core.logic.switch',
     merge: 'core.logic.merge',
@@ -287,28 +278,6 @@ function isTrigger(type) {
 function boolLit(v) {
     return v ? 'true' : 'false';
 }
-/** An object key: a bare identifier when legal, otherwise a quoted string. */
-function key(k) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) ? k : tsLiteral(k);
-}
-/** Render an options object from present entries; '' when nothing is present. */
-function opts(entries) {
-    const parts = entries.filter(([, v]) => v !== undefined).map(([k, v]) => `${key(k)}: ${v}`);
-    return parts.length ? `{ ${parts.join(', ')} }` : '';
-}
-/**
- * Plain JSON data as source, in the `{ k: v }` / `[a, b]` spelling the
- * printers use (a form field's `options`, `rules`, `defaultValue`).
- */
-function dataSource(v) {
-    if (Array.isArray(v))
-        return `[${v.map(dataSource).join(', ')}]`;
-    if (v !== null && typeof v === 'object') {
-        const parts = Object.entries(v).filter(([, x]) => x !== undefined).map(([k, x]) => `${key(k)}: ${dataSource(x)}`);
-        return parts.length ? `{ ${parts.join(', ')} }` : '{}';
-    }
-    return tsLiteral(v);
-}
 /** A collector for indented source lines. */
 class Emit {
     indentUnit;
@@ -445,12 +414,6 @@ function emitVal(v, imp, inputNames) {
 function emitBareExpr(raw, imp, inputNames) {
     return emitRef(raw, imp, inputNames);
 }
-/** Render an object literal `{ k: <src>, … }` from pre-rendered value sources; '' when empty. */
-function objLit(entries) {
-    if (entries.length === 0)
-        return '';
-    return `{ ${entries.map(([k, v]) => `${key(k)}: ${v}`).join(', ')} }`;
-}
 /** A map of `{name: value}` inputs (headers / query / connector fields) → object-literal source. */
 function emitValMap(m, imp, inputNames) {
     if (!m || typeof m !== 'object')
@@ -652,6 +615,26 @@ function liftRegistered(node, impl = registeredImpl(node), graph) {
                 throw new Error(`decompile: ${message}`);
             warnOnce(message);
         },
+        sidecar: (path) => runReadSidecar?.(path),
+        flowId: runFlowId,
+        definitionOf: (n) => runDefs.get(`${n.type}@${n.typeVersion}`) ?? runDefs.get(n.type),
+        attached: (port, limit = Infinity) => {
+            const found = [];
+            for (const e of graph?.outEdges(node.id) ?? []) {
+                if (e.sourcePort !== port || found.length >= limit)
+                    continue;
+                const n = graph.byId.get(e.targetNodeId);
+                if (n === undefined)
+                    continue;
+                graph.accounted.add(e);
+                found.push(n);
+            }
+            return found;
+        },
+        attachedIds: (port) => (graph?.outEdges(node.id) ?? [])
+            .filter((e) => e.sourcePort === port && graph.byId.has(e.targetNodeId))
+            .map((e) => e.targetNodeId),
+        absorb: (id, compiledId) => { runAbsorbed.set(id, compiledId); },
         outPorts: () => (graph?.outEdges(node.id) ?? []).map((e) => e.sourcePort),
         convergedFanOut: () => graph?.convergedFanOut(node.id) === true,
     };
@@ -713,35 +696,12 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
     if (lifted !== undefined)
         return lifted;
     switch (node.type) {
-        case T.createOutgoingCall:
-        case T.endCall: {
-            const i = (node.inputs ?? {});
-            const v = (x) => {
-                const raw = typeof x === 'string' ? x : String(x?.expression ?? x ?? '');
-                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames)
-                    : raw.startsWith('$vars.') ? emitBareExpr(raw, imp, inputNames)
-                        : tsLiteral(raw);
-            };
-            if (node.type === T.createOutgoingCall) {
-                return `${imp.use('createOutgoingCall')}(${opts([['from', v(i.from)], ['to', v(i.to)]])})`;
-            }
-            return `${imp.use('endCall')}(${opts([['callContext', v(i.callContext)]])})`;
-        }
-        case T.inlineAgent:
-        case T.conversationalAgent:
-        case T.voiceAgent:
-            return emitAgentCluster(node, imp, inputNames, graph);
         default:
             // A connector action node: `uipath.connector.<key>.<action>` (but NOT the
             // event nodes `uipath.connector.event.*` / `.trigger.*`, which are triggers).
             if (node.type.startsWith('uipath.connector.') && !node.type.startsWith('uipath.connector.event.') && !node.type.startsWith('uipath.connector.trigger.')) {
                 return emitConnector(node, imp, inputNames, o);
             }
-            {
-                const published = emitPublishedResource(node, imp, inputNames);
-                if (published !== undefined)
-                    return published;
-            }
             // A mid-flow connector EVENT wait (`uipath.connector.event.<key>.<event>`
             // placed as a step rather than as the start node).
             if (node.type.startsWith('uipath.connector.event.')) {
@@ -837,688 +797,6 @@ 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. `'standard'` is the
-    // sidecar's default, so only another value is the author's. (Naming it no
-    // longer selects a definition version — the node's `{ version }` carries that,
-    // flow-builder-sdk#956.)
-    const mode = node.type === T.inlineAgent && typeof settings.mode === 'string'
-        && settings.mode !== 'standard'
-        ? 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 } : {}),
-    };
-}
-/**
- * Where a context-index resource node keeps its identity, read in the order
- * that holds for every writer.
- *
- * SDK compile writes `indexId` / `indexName` / `folderPath` onto the node. The
- * canvas and the CLI do not: their node carries only `inputs.source`, and the
- * identity lives in two other places.
- *
- *  - The node TYPE, `…context.index.<slug>.<uuid>`: the uuid is the index id
- *    (the `ContextIndexRef.id` JSDoc says to read it there).
- *  - The resource sidecar `<agent source>/resources/<inputs.source>/resource.json`,
- *    whose `name` is the index's real name (the one the slug is made from) and
- *    whose `folderPath` is its folder. `display.label` is only what the canvas
- *    shows, and a canvas rename changes it.
- *
- * So the id comes from the type (then `inputs.indexId`). The name is the first
- * of `inputs.indexName`, sidecar `name`, sidecar `indexName`, label that slugs to
- * the type's slug, else the first one present in that order. Compile derives
- * the type from `slug(name)` + id, so when the chosen name does not slug back to
- * the type's slug the recompiled node gets a different type, and that is warned.
- */
-function contextIndexIdentity(agent, c, rPlain) {
-    const fromType = parseContextIndexType(c.type);
-    const sidecar = contextResourceSidecar(agent, c);
-    const sidecarText = (k) => typeof sidecar?.[k] === 'string' && sidecar[k] !== '' ? sidecar[k] : undefined;
-    const label = typeof c.display?.label === 'string' && c.display.label !== '' ? c.display.label : undefined;
-    // The canvas can set both sidecar `name` and `indexName`, and they can differ.
-    // The one that slugs to the type's slug is the one the type was built from, so
-    // it wins; the fixed order is the fallback when none matches.
-    const candidates = [rPlain(c, 'indexName'), sidecarText('name'), sidecarText('indexName'), label]
-        .filter((n) => n !== undefined);
-    const name = (fromType?.slug ? candidates.find((n) => contextIndexSlug(n) === fromType.slug) : undefined)
-        ?? candidates[0] ?? '';
-    const id = (fromType?.id || undefined) ?? rPlain(c, 'indexId') ?? '';
-    if (fromType !== undefined && fromType.slug !== '' && contextIndexSlug(name) !== fromType.slug) {
-        warnOnce(`context index "${c.id}" on agent "${agent.id}": its node type names the index "${fromType.slug}", `
-            + `but the name decompile recovered, ${JSON.stringify(name)}, slugs to "${contextIndexSlug(name)}", so compile `
-            + `will write a different node type. Set \`name\` to the index's real name`
-            + (sidecar === undefined ? ', or keep the resources/ folder beside the .flow so decompile can read it.' : '.'));
-    }
-    return { name, id, folderPath: rPlain(c, 'folderPath') ?? sidecarText('folderPath'), sidecar };
-}
-/** The retrieval modes `ContextIndexRef.retrievalMode` can hold. */
-const CONTEXT_RETRIEVAL_MODES = new Set(['semantic', 'structured', 'deeprag', 'batchtransform']);
-/** The `settings` keys of a context `resource.json` that {@link contextIndexSettings} reads or checks. */
-const CONTEXT_SETTINGS_KEYS = new Set([
-    'retrievalMode', 'query', 'folderPathPrefix', 'threshold', 'resultCount', 'fileExtension',
-    'citationMode', 'webSearchGrounding', 'outputColumns',
-]);
-/**
- * A context index's retrieval settings, as the `context: [...]` entry's option
- * rows (`retrievalMode`, `query`, `threshold`, `resultCount`, `fileExtension`),
- * each left out when it is what compile writes anyway.
- *
- * The inverse of `contextResourceJson` (serialize.ts). Read from the sidecar's
- * `settings` first: a node the canvas or the CLI placed keeps its inputs minimal
- * (`inputs.source`), so `resource.json` is the only copy, and it is what the
- * runtime reads. The node's own inputs (the SDK writes both) answer when there
- * is no sidecar. Before #1183 neither was read, so a no-edit round trip reset
- * every setting to the SDK default without a word.
- *
- * The query is variant-tagged in the sidecar and mode-tagged on the node:
- *
- *  - `dynamic` / `prompt` → a plain string (the guidance the model reads);
- *  - `static` / `text-builder` whose text is a `=js:` expression → that
- *    expression, which compile writes back as `text-builder` / `static`;
- *  - `static` with `''` is the canvas's spelling of "no query", as the SDK's
- *    `dynamic` with `''` is: left out.
- *
- * A setting the SDK cannot express (a `static` query of plain text, an
- * `argument` query, deeprag citations off, batchtransform web grounding off or
- * output columns, a folder-path prefix, an unknown mode or key) is reported:
- * a warning, or an error under `--strict`. Compile would write the SDK's
- * value instead, so it is never dropped silently.
- */
-function contextIndexSettings(agent, c, sidecar) {
-    const settings = sidecar?.settings && typeof sidecar.settings === 'object' && !Array.isArray(sidecar.settings)
-        ? sidecar.settings : undefined;
-    const ni = (c.inputs ?? {});
-    const where = `context index "${c.id}" on agent "${agent.id}"`;
-    const lossy = (what) => {
-        const message = `${where}: ${what}, which \`context: [...]\` cannot express, so compile writes the SDK's `
-            + `value instead. Edit that setting in the canvas after merging, or keep the original resource.json.`;
-        if (runStrict)
-            throw new Error(`decompile: ${message}`);
-        warnOnce(message);
-    };
-    const textOf = (v) => (typeof v === 'string' ? v : undefined);
-    const numOf = (v) => {
-        const raw = unwrapPlain(v);
-        return typeof raw === 'number' && Number.isFinite(raw) ? raw : undefined;
-    };
-    const valueOf = (v) => (v && typeof v === 'object' ? v.value : undefined);
-    // Retrieval mode.
-    const rawMode = textOf(settings?.retrievalMode) ?? textOf(unwrapSource(ni.retrievalMode));
-    let mode = CONTEXT_INDEX_DEFAULTS.retrievalMode;
-    if (rawMode !== undefined && rawMode !== '') {
-        if (CONTEXT_RETRIEVAL_MODES.has(rawMode))
-            mode = rawMode;
-        else
-            lossy(`its retrieval mode is ${JSON.stringify(rawMode)}`);
-    }
-    const sidecarQuery = (() => {
-        const q = settings?.query;
-        if (!q || typeof q !== 'object')
-            return undefined;
-        if (q.variant === 'dynamic')
-            return { kind: 'prompt', text: textOf(q.description) ?? '' };
-        if (q.variant === 'static')
-            return { kind: 'text', text: textOf(q.value) ?? '' };
-        if (q.variant === 'argument')
-            return { kind: 'argument', text: textOf(q.value) ?? '' };
-        lossy(`its query has variant ${JSON.stringify(q.variant)}`);
-        return undefined;
-    })();
-    const nodeQuery = (() => {
-        const q = ni.query;
-        if (typeof q === 'string')
-            return q === '' ? undefined : { kind: q.startsWith('=js:') ? 'text' : 'prompt', text: q };
-        if (!q || typeof q !== 'object')
-            return undefined;
-        const t = q;
-        if (t.mode === 'text-builder')
-            return { kind: 'text', text: textOf(t.textValue) ?? '' };
-        if (t.mode === 'variable')
-            return { kind: 'argument', text: textOf(t.argumentPath) ?? '' };
-        return { kind: 'prompt', text: textOf(t.promptValue) ?? '' };
-    })();
-    const query = sidecarQuery ?? nodeQuery;
-    let querySrc;
-    if (query?.kind === 'prompt' && query.text !== '')
-        querySrc = tsLiteral(query.text);
-    else if (query?.kind === 'text' && query.text.startsWith('=js:'))
-        querySrc = tsLiteral(query.text);
-    else if (query?.kind === 'text' && query.text !== '')
-        lossy(`its query is static text (${JSON.stringify(query.text)})`);
-    else if (query?.kind === 'argument')
-        lossy(`its query is the agent argument ${JSON.stringify(query.text)}`);
-    // Numbers and the file extension.
-    const threshold = numOf(settings?.threshold) ?? numOf(ni.threshold);
-    const resultCount = numOf(settings?.resultCount) ?? numOf(ni.resultCount);
-    const fileExtension = textOf(valueOf(settings?.fileExtension)) ?? textOf(unwrapSource(ni.fileExtension));
-    // The node's flat `All` is the platform's node default for every mode; only
-    // the resource's per-mode default is what compile would write anyway.
-    const defaultExtension = ownEntry(CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, mode) ?? 'All';
-    const extensionSrc = fileExtension === undefined || fileExtension === '' || fileExtension === defaultExtension
-        || (settings?.fileExtension === undefined && fileExtension === 'All')
-        ? undefined : tsLiteral(fileExtension);
-    // What compile writes as constants; anything else has no field.
-    if (mode === 'deeprag') {
-        const citation = textOf(valueOf(settings?.citationMode)) ?? textOf(unwrapSource(ni.citations));
-        if (citation !== undefined && !['Inline', 'enabled'].includes(citation))
-            lossy(`its citation mode is ${JSON.stringify(citation)}`);
-    }
-    if (mode === 'batchtransform') {
-        const grounding = textOf(valueOf(settings?.webSearchGrounding)) ?? textOf(valueOf(ni.webSearchGrounding));
-        if (grounding !== undefined && !['Enabled', 'enabled'].includes(grounding))
-            lossy(`its web search grounding is ${JSON.stringify(grounding)}`);
-        const columns = settings?.outputColumns ?? ni.outputColumns;
-        if (Array.isArray(columns) && columns.length > 0)
-            lossy(`it has ${columns.length} output column(s)`);
-    }
-    // The folder-path prefix: variant-tagged in the sidecar, mode-tagged on the node.
-    const field = (v, k) => (v && typeof v === 'object' ? textOf(v[k]) : undefined);
-    const prefixText = settings?.folderPathPrefix !== undefined
-        ? field(settings.folderPathPrefix, 'value') ?? field(settings.folderPathPrefix, 'description') ?? ''
-        : field(ni.folderPathPrefix, 'textValue') ?? field(ni.folderPathPrefix, 'promptValue') ?? '';
-    if (prefixText !== '')
-        lossy(`its folder-path prefix is ${JSON.stringify(prefixText)}`);
-    for (const k of Object.keys(settings ?? {})) {
-        if (!CONTEXT_SETTINGS_KEYS.has(k))
-            lossy(`its resource.json settings carry ${JSON.stringify(k)}`);
-    }
-    return [
-        ['query', querySrc],
-        ['retrievalMode', mode !== CONTEXT_INDEX_DEFAULTS.retrievalMode ? tsLiteral(mode) : undefined],
-        ['threshold', threshold !== undefined && threshold !== CONTEXT_INDEX_DEFAULTS.threshold ? tsNumber(threshold) : undefined],
-        ['resultCount', resultCount !== undefined && resultCount !== CONTEXT_INDEX_DEFAULTS.resultCount ? tsNumber(resultCount) : undefined],
-        ['fileExtension', extensionSrc],
-    ];
-}
-/**
- * A context resource's `resource.json` sidecar, parsed; `undefined` when it is
- * not beside the `.flow`, or (with a warning) when it is not a JSON object.
- */
-function contextResourceSidecar(agent, c) {
-    const agentSource = unwrapSource(agent.inputs?.source);
-    const resourceSource = unwrapSource(c.inputs?.source);
-    if (!agentSource || !resourceSource)
-        return undefined;
-    const path = `${agentSource}/resources/${resourceSource}/resource.json`;
-    const raw = runReadSidecar?.(path);
-    if (raw === undefined)
-        return undefined;
-    try {
-        const json = JSON.parse(raw);
-        if (json && typeof json === 'object' && !Array.isArray(json))
-            return json;
-    }
-    catch {
-        // Reported below with the non-object case.
-    }
-    warnOnce(`context index "${c.id}": ${path} is not valid JSON, so its name and folder decompile from the node.`);
-    return undefined;
-}
-/**
- * An AGENT and its attached resources — the inline autonomous agent, the
- * conversational agent, and the voice agent.
- *
- * The cluster is a node plus artifact nodes on its `tool` / `context` /
- * `escalation` / `memory` handles, so this walks those edges and recovers each
- * resource as an argument rather than as a step (see {@link ARTIFACT_PORTS}).
- *
- * **The author's input NAMES are not recoverable, and that is by design.** The
- * platform does not send an agent the names you declared: it keys each argument
- * by the reference PATH, `__`-joined (`$vars.prep.output` → `prep__output`), and
- * only those flat names survive in the emitted file. Recovery therefore uses
- * them for both the `inputs` keys and the `{{input.…}}` placeholders — the same
- * arguments reach the model, spelled the platform's way. (Node ids are
- * preserved exactly; only these logical names change.)
- */
-function emitAgentCluster(node, imp, inputNames, graph) {
-    // 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;
-    };
-    const num = (v) => {
-        const raw = unwrapPlain(v);
-        return typeof raw === 'number' ? String(raw) : undefined;
-    };
-    // 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')
-        .map((v) => ({ flatName: v.id, binding: v.binding }))
-        .sort((a, b) => b.binding.length - a.binding.length);
-    const unrender = (text) => {
-        let out = text;
-        for (const r of refs)
-            out = out.split(r.binding).join(`{{input.${r.flatName}}}`);
-        return out;
-    };
-    const promptSrc = (v) => {
-        const raw = plain(v);
-        return raw === undefined ? undefined : tsLiteral(unrender(raw));
-    };
-    const inputRows = refs
-        // Emit in the file's own order, not the length-sorted one.
-        .slice()
-        .sort((a, b) => vars.findIndex((v) => v.id === a.flatName) - vars.findIndex((v) => v.id === b.flatName))
-        .map((r) => {
-        return [r.flatName, emitBareExpr(wireExprBody(r.binding), imp, inputNames)];
-    });
-    const outVars = (Array.isArray(i.agentOutputVariables) ? i.agentOutputVariables : []);
-    const returns = outVars.length
-        ? objLit(outVars.map((v) => [String(v.id ?? ''), tsLiteral(String(v.type ?? 'string'))]))
-        : undefined;
-    // The resources, from the agent's own artifact edges. Each edge read here is
-    // carried by the agent spec (edge accounting, #1125); `limit` is for a port
-    // the spec carries only one resource on.
-    const resource = (port, limit = Infinity) => {
-        const found = [];
-        for (const e of graph?.outEdges(node.id) ?? []) {
-            if (e.sourcePort !== port || found.length >= limit)
-                continue;
-            const n = graph.byId.get(e.targetNodeId);
-            if (n === undefined)
-                continue;
-            graph.accounted.add(e);
-            found.push(n);
-        }
-        return found;
-    };
-    // Record what compile will call each folded resource node. Serialize mints
-    // `uid(scope, \`${step.name}<Kind>\`)` per resource, in spec order, and the
-    // spec order is this edge order: the first is `<agent><Kind>`, the n-th
-    // `<agent><Kind><n>` (claimId's dedupe). Only the first memory is recovered,
-    // so every further memory maps to `undefined`.
-    //
-    // When a port's nodes do not ALL carry those ids (the canvas or the CLI named
-    // them), every resource on the port is written with its own `nodeId`, and
-    // compile keeps the file's ids. All of them, not only the odd one: compile
-    // numbers the derived ids in order, so a derived id after an explicit one
-    // would come out one lower than the file's.
-    // This reads the edges directly, not through `resource()`: it must see EVERY
-    // artifact edge, including ones the spec does not carry, and it must not
-    // account for any edge.
-    const keepIds = new Set();
-    for (const [port, kind, emittedCount] of [
-        ['context', 'Context', Infinity], ['tool', 'Tool', Infinity],
-        ['escalation', 'Escalation', Infinity], ['memory', 'Memory', 1],
-    ]) {
-        const targets = (graph?.outEdges(node.id) ?? [])
-            .filter((e) => e.sourcePort === port && graph.byId.has(e.targetNodeId))
-            .map((e) => e.targetNodeId);
-        const keep = port !== 'memory'
-            && targets.some((id, k) => id !== derivedResourceNodeId(node.id, kind, k));
-        targets.forEach((id, k) => {
-            if (keep)
-                keepIds.add(id);
-            runAbsorbed.set(id, keep ? id : k >= emittedCount ? undefined : derivedResourceNodeId(node.id, kind, k));
-        });
-    }
-    /**
-     * The `nodeId` / `source` entries for resource node `r`: each only when it
-     * differs from what compile derives (`derivedSource`), so a flow compile
-     * wrote decompiles without them.
-     */
-    const placement = (r, derivedSource) => {
-        const source = unwrapSource((r.inputs ?? {}).source);
-        return [
-            ['nodeId', keepIds.has(r.id) ? tsLiteral(r.id) : undefined],
-            ['source', source !== undefined && source !== '' && source !== derivedSource ? tsLiteral(source) : undefined],
-        ];
-    };
-    /** A tool's options plus its placement; `seed` is the ref compile derives the tool's directory from. */
-    const toolOpts = (t, seed, entries) => opts([...entries, ...placement(t, derivedToolSource(runFlowId, node.id, seed))]);
-    const rInputs = (n) => (n.inputs ?? {});
-    const rPlain = (n, k) => {
-        const raw = unwrapSource(rInputs(n)[k]);
-        return raw === undefined || raw === '' ? undefined : raw;
-    };
-    const toolSrc = resource('tool').map((t) => {
-        const ti = rInputs(t);
-        const type = t.type;
-        if (type === 'uipath.agent.resource.tool.clientside') {
-            const schemaTypes = (v) => {
-                const props = v?.properties;
-                if (!props || Object.keys(props).length === 0)
-                    return undefined;
-                return objLit(Object.entries(props).map(([k, x]) => [k, tsLiteral(String(x?.type ?? 'string'))]));
-            };
-            return toolOpts(t, { kind: 'clientside', name: rPlain(t, 'name') ?? '' }, [
-                ['kind', tsLiteral('clientside')],
-                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
-                ['description', rPlain(t, 'description') !== undefined ? tsLiteral(rPlain(t, 'description')) : undefined],
-                ['inputs', schemaTypes(ti.inputSchema)],
-                ['returns', schemaTypes(ti.outputSchema)],
-            ]);
-        }
-        if (type === 'uipath.agent.resource.tool.builtin.httprequest') {
-            // A field is authored only when it left prompt mode (text-builder).
-            const fixed = (k) => {
-                const row = ti[k];
-                if (!row || row.mode !== 'text-builder')
-                    return undefined;
-                const v = row.textValue;
-                return typeof v === 'number' ? String(v) : typeof v === 'string' ? tsLiteral(v) : JSON.stringify(v);
-            };
-            // `name` is not recovered, so compile derives the directory from the default.
-            return toolOpts(t, { kind: 'httpRequest' }, [
-                ['kind', tsLiteral('httpRequest')],
-                ['url', fixed('url')], ['method', fixed('method')],
-                ['headers', fixed('headers')], ['params', fixed('params')],
-                ['body', fixed('body')], ['timeout', fixed('timeout')],
-            ]);
-        }
-        if (type.startsWith('uipath.agent.resource.tool.mcp.')) {
-            return toolOpts(t, { kind: 'mcp', name: '', key: rPlain(t, 'referenceKey') ?? '' }, [
-                ['kind', tsLiteral('mcp')],
-                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
-                ['key', tsLiteral(rPlain(t, 'referenceKey') ?? '')],
-                // The mapper's field name for the canonical server slug.
-                ['slug', rPlain(t, 'serverUrl') !== undefined ? tsLiteral(rPlain(t, 'serverUrl')) : undefined],
-                ['folderPath', rPlain(t, 'folderPath') !== undefined ? tsLiteral(rPlain(t, 'folderPath')) : undefined],
-                ['mcpType', rPlain(t, 'mcpType') !== undefined ? tsLiteral(rPlain(t, 'mcpType')) : undefined],
-            ]);
-        }
-        if (type.startsWith('uipath.agent.resource.tool.a2a.')) {
-            return toolOpts(t, { kind: 'a2a', name: '', slug: '', key: rPlain(t, 'referenceKey') ?? '' }, [
-                ['kind', tsLiteral('a2a')],
-                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
-                ['key', tsLiteral(rPlain(t, 'referenceKey') ?? '')],
-                ['slug', tsLiteral(rPlain(t, 'slug') ?? '')],
-                ['folderPath', rPlain(t, 'folderPath') !== undefined ? tsLiteral(rPlain(t, 'folderPath')) : undefined],
-            ]);
-        }
-        if (type.startsWith('uipath.agent.resource.tool.builtin.')) {
-            const tool = type.slice('uipath.agent.resource.tool.builtin.'.length);
-            return toolOpts(t, { kind: 'builtin', tool }, [
-                ['kind', tsLiteral('builtin')],
-                ['tool', tsLiteral(tool)],
-                ['description', rPlain(t, 'description') !== undefined ? tsLiteral(rPlain(t, 'description')) : undefined],
-            ]);
-        }
-        if (type.startsWith('uipath.agent.resource.tool.ixp.')) {
-            const tail = type.slice('uipath.agent.resource.tool.ixp.'.length);
-            const projectId = tail.slice(tail.indexOf('.') + 1);
-            return toolOpts(t, { kind: 'ixp', name: '', projectId }, [
-                ['kind', tsLiteral('ixp')],
-                ['projectId', tsLiteral(projectId)],
-                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
-            ]);
-        }
-        // The per-instance resource kinds (process / api / flow / maestro / agent /
-        // function): the key is the node type's tail, the rest is a binding pair.
-        const PROCESS_NS = [
-            ['uipath.agent.resource.tool.processorchestration.', 'maestro'],
-            ['uipath.agent.resource.tool.process.', 'process'],
-            ['uipath.agent.resource.tool.function.', 'function'],
-            ['uipath.agent.resource.tool.api.', 'api'],
-            ['uipath.agent.resource.tool.flow.', 'flow'],
-            ['uipath.agent.resource.tool.agent.', 'agent'],
-        ];
-        const ns = PROCESS_NS.find(([prefix]) => type.startsWith(prefix));
-        if (ns) {
-            const def = runDefs.get(`${type}@${t.typeVersion}`) ?? runDefs.get(type);
-            const values = (def?.model?.bindings?.values ?? []);
-            const bound = (n) => {
-                const row = values.find((v) => v.name === n);
-                return typeof row?.default === 'string' ? row.default : undefined;
-            };
-            const key = type.slice(ns[0].length);
-            return toolOpts(t, { kind: 'process', name: '', folderPath: '', key }, [
-                ['kind', tsLiteral(ns[1])],
-                ['key', tsLiteral(key)],
-                ['name', tsLiteral(bound('name') ?? rPlain(t, 'name') ?? '')],
-                ['folderPath', tsLiteral(bound('folderPath') ?? '')],
-            ]);
-        }
-        return opts([['kind', tsLiteral('builtin')], ['tool', tsLiteral('summarize')]]); // unreachable in practice
-    });
-    const contextSrc = resource('context').map((c) => {
-        const { name, id, folderPath, sidecar } = contextIndexIdentity(node, c, rPlain);
-        // Compile labels the node with `name`; a canvas rename is kept as `label`.
-        const label = typeof c.display?.label === 'string' && c.display.label !== '' && c.display.label !== name
-            ? c.display.label : undefined;
-        return opts([
-            ['name', tsLiteral(name)],
-            ['id', tsLiteral(id)],
-            ['folderPath', folderPath !== undefined ? tsLiteral(folderPath) : undefined],
-            ['folderKey', rPlain(c, 'folderKey') !== undefined ? tsLiteral(rPlain(c, 'folderKey')) : undefined],
-            // `query` and the retrieval settings, from resource.json or the node (#1183).
-            ...contextIndexSettings(node, c, sidecar),
-            ['label', label !== undefined ? tsLiteral(label) : undefined],
-            ...placement(c, derivedContextSource(runFlowId, node.id, id)),
-        ]);
-    });
-    const escalationSrc = resource('escalation').map((e) => {
-        const ei = rInputs(e);
-        const recipients = Array.isArray(ei.recipients)
-            ? ei.recipients.map((r) => tsText(r.value))
-            : [];
-        const outcomeNames = Object.keys((ei.outcomeMapping ?? {}));
-        const isQuickForm = e.type === 'uipath.agent.resource.escalation.quick-form';
-        const rows = isQuickForm
-            ? (ei.schema?.fields ?? [])
-            : [];
-        const app = ei.app;
-        const extra = (ei._additionalProps ?? {});
-        return opts([
-            ['variant', isQuickForm ? tsLiteral('quick-form') : undefined],
-            ['name', tsLiteral(rPlain(e, 'name') ?? '')],
-            ['description', rPlain(e, 'description') !== undefined ? tsLiteral(rPlain(e, 'description')) : undefined],
-            ['fields', rows.length ? `[${rows.map((f) => {
-                    const id = String(f.id ?? '');
-                    const direction = String(f.direction ?? 'output');
-                    // Every row key the source cannot carry is reported, never dropped
-                    // silently: a warning, an error under --strict (#1250).
-                    const loss = formFieldRowLoss(f, 'escalation');
-                    if (loss.length > 0) {
-                        const message = formFieldRowLossMessage(`quick-form escalation ${JSON.stringify(rPlain(e, 'name') ?? e.id)} on agent ${JSON.stringify(node.id)}`, id, loss);
-                        if (runStrict)
-                            throw new Error(`decompile: ${message}`);
-                        warnOnce(message);
-                    }
-                    return opts([
-                        ['id', tsText(f.id)],
-                        // serialize defaults a row's label to its id.
-                        ['label', typeof f.label === 'string' && f.label !== id ? tsLiteral(f.label) : undefined],
-                        ['type', tsLiteral(sourceFormFieldType(f.type ?? 'string'))],
-                        ['direction', tsLiteral(direction)],
-                        ['required', typeof f.required === 'boolean' && direction !== 'input' ? String(f.required) : undefined],
-                        ...formFieldSettingsSource(liftFormFieldSettings(f), dataSource),
-                    ]);
-                }).join(', ')}]` : undefined],
-            ['app', app === undefined ? undefined : opts([
-                    ['key', tsText(app.key)],
-                    ['name', tsText(app.name)],
-                    ['folderPath', typeof app.folderPath === 'string' && app.folderPath !== '' ? tsLiteral(app.folderPath) : undefined],
-                ])],
-            ['recipients', recipients.length ? `[${recipients.join(', ')}]` : undefined],
-            ['outcomes', outcomeNames.length ? `[${outcomeNames.map((o) => tsLiteral(o)).join(', ')}]` : undefined],
-            ['taskTitle', typeof extra.taskTitle === 'string' && extra.taskTitle !== '' ? tsLiteral(extra.taskTitle) : undefined],
-            // 'medium' is the platform default.
-            ['priority', typeof extra.priority === 'string' && extra.priority !== 'medium' ? tsLiteral(extra.priority) : undefined],
-            ...placement(e, derivedEscalationSource(runFlowId, node.id, rPlain(e, 'name') ?? '')),
-        ]);
-    });
-    const mem = resource('memory', 1)[0];
-    const memorySrc = mem === undefined ? undefined : (() => {
-        // The memory's id is the node type's tail; the def carries it too.
-        const tail = mem.type.slice('uipath.agent.resource.memory.'.length);
-        const id = tail.slice(tail.indexOf('.') + 1);
-        const mi = rInputs(mem);
-        return opts([
-            ['name', tsLiteral(rPlain(mem, 'name') ?? '')],
-            ['id', tsLiteral(id)],
-            ['description', rPlain(mem, 'description') !== undefined ? tsLiteral(rPlain(mem, 'description')) : undefined],
-            // The platform defaults: few-shot on, similarity 0, k 3, hybrid search.
-            ['dynamicFewShotLearning', unwrapPlain(mi.dynamicFewShotLearning) === false ? 'false' : undefined],
-            ['semanticSimilarity', num(mi.semanticSimilarity) !== undefined && num(mi.semanticSimilarity) !== '0' ? num(mi.semanticSimilarity) : undefined],
-            ['kValue', num(mi.kValue) !== undefined && num(mi.kValue) !== '3' ? num(mi.kValue) : undefined],
-            ['searchMode', rPlain(mem, 'searchMode') !== undefined && rPlain(mem, 'searchMode') !== 'hybrid'
-                    ? tsLiteral(rPlain(mem, 'searchMode')) : undefined],
-        ]);
-    })();
-    const guardrails = Array.isArray(i.guardrails) && i.guardrails.length > 0
-        ? JSON.stringify(i.guardrails)
-        : undefined;
-    const list = (items) => (items.length ? `[${items.join(', ')}]` : undefined);
-    if (node.type === T.voiceAgent) {
-        const v = (i.voice ?? {});
-        const voiceSrc = Object.keys(v).length === 0 ? undefined : opts([
-            ['model', typeof v.model === 'string' ? tsLiteral(v.model) : undefined],
-            ['persona', typeof v.persona === 'string' ? tsLiteral(v.persona) : undefined],
-            ['temperature', num(v.temperature)],
-            ['maxTokens', num(v.maxTokens)],
-        ]);
-        return `${imp.use('voiceAgent')}(${opts([
-            ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
-            ['inputs', inputRows.length ? objLit(inputRows) : undefined],
-            ['callContext', (() => {
-                    const raw = plain(i.callContext) ?? '';
-                    const js = wireExprBody(raw);
-                    // Anything but a `$vars.` reference stays the wire text verbatim.
-                    return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : tsLiteral(raw);
-                })()],
-            ['voice', voiceSrc],
-            ['maxIterations', num(i.maxIterations)],
-            ['source', tsLiteral(plain(i.source) ?? '')],
-        ])})`;
-    }
-    if (node.type === T.conversationalAgent) {
-        const st = (i.conversationalAgentSettings ?? {});
-        const settingExpr = (k) => {
-            // `unwrapSource` rather than a string test: since the envelope reaches
-            // these five keys (migrate's `NESTED_BINDING_INPUTS`), a bare string is
-            // only what a pre-1.6 file carries. Reading strings alone made every
-            // modern file decompile to a conversational agent with no turn wiring.
-            const raw = unwrapSource(st[k]);
-            if (raw === undefined || raw === '' || raw === '=js:')
-                return undefined;
-            // Only a `=js:` value is an expression: `emitRef` lowers a single path to
-            // `out(...)` and anything composite to a `js` template. Any other string
-            // is literal text, as the product reads it (flow-schema
-            // `coerceToExpressionValue`), even when it looks like `$vars.…`.
-            return raw.startsWith('=js:') ? emitRef(raw.slice(4), imp, inputNames) : tsLiteral(raw);
-        };
-        // `'simple'` mode DERIVES the four runtime fields from `context`, so only
-        // the context binding is the author's; recovering the derived ones would
-        // re-emit them as hand-bound custom fields.
-        const mode = typeof st.mode === 'string' ? st.mode : 'simple';
-        const settingsSrc = mode === 'custom'
-            ? opts([
-                ['mode', tsLiteral('custom')],
-                ['conversationId', settingExpr('conversationId')],
-                ['exchangeId', settingExpr('exchangeId')],
-                ['messages', settingExpr('messages')],
-                ['userSettings', settingExpr('userSettings')],
-            ])
-            : opts([['context', settingExpr('context')]]);
-        return `${imp.use('conversationalAgent')}(${opts([
-            ['model', tsLiteral(plain(i.model) ?? '')],
-            ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
-            // `settings` is required on ConversationalAgentInputs, so an empty one
-            // stays as `{}`, which check then reports as CONV_AGENT_NO_TURN.
-            ['settings', settingsSrc || '{}'],
-            ['temperature', num(i.temperature)],
-            ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
-            ['maxIterations', num(i.maxIterations)],
-            ['guardrails', guardrails],
-            ['source', tsLiteral(plain(i.source) ?? '')],
-        ])})`;
-    }
-    return `${imp.use('inlineAgent')}(${opts([
-        ['model', tsLiteral(plain(i.model) ?? '')],
-        ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
-        ['userPrompt', promptSrc(i.userPrompt) ?? tsLiteral('')],
-        ['inputs', inputRows.length ? objLit(inputRows) : undefined],
-        ['returns', returns],
-        ['temperature', num(i.temperature)],
-        ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
-        ['maxIterations', num(i.maxIterations)],
-        ['mode', plain(i.mode) !== undefined ? tsLiteral(plain(i.mode)) : undefined],
-        ['guardrails', guardrails],
-        ['context', list(contextSrc)],
-        ['tools', list(toolSrc)],
-        ['escalation', list(escalationSrc)],
-        ['memory', memorySrc],
-        // The agent's directory uuid is derived from the flow and step ids, but a
-        // decompiled flow must keep the ORIGINAL — the sidecar lives at
-        // `<source>/agent.json`, so a re-derived one would point at nothing.
-        ['source', tsLiteral(plain(i.source) ?? '')],
-    ])})`;
-}
 /**
  * A connector EVENT subscription, shared by the trigger (`onEvent`) and the
  * mid-flow wait (`waitForEvent`) — the same node body in both places, so the
@@ -1608,83 +886,6 @@ function emitEventSubscription(node, imp, inputNames) {
         ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
     ]) + unboundMarker(node, { connection: conn, folder }, connector, event);
 }
-/**
- * Read back the expression template older SDK builds emitted on an in-solution
- * `agent()` input (#1013): `{ type: 'literal', expression: '{{ <js> }}' }`.
- * serialize now emits the platform's `{ type: 'jsExpression', expression }`
- * instead, but `.flow` files written between 2026-08-10 and the fix still carry
- * the template, and the runtime evaluates it (the agent receives the value, not
- * the braces). So on an in-solution agent node a literal that is exactly one
- * `{{ … }}` is that expression, and it decompiles to the reference it was
- * written from rather than to a string. Anything else is returned unchanged.
- */
-function legacyAgentTemplateInput(v) {
-    if (!v || typeof v !== 'object' || Array.isArray(v))
-        return v;
-    const o = v;
-    if (o.type !== 'literal' || typeof o.expression !== 'string')
-        return v;
-    const m = /^\{\{\s*([\s\S]+?)\s*\}\}$/.exec(o.expression);
-    if (!m || m[1].includes('}}') || m[1].includes('{{'))
-        return v;
-    return { ...o, type: 'jsExpression', expression: m[1] };
-}
-function emitPublishedResource(node, imp, inputNames) {
-    // The published AGENT resource — the same shape as the process family's
-    // node types (identity in the definition's binding pair, contract in its
-    // output schema), which lift themselves (nodes/process/flow/).
-    const FAMILIES = [
-        { prefix: 'uipath.core.agent.', factory: 'agent' },
-    ];
-    const family = FAMILIES.find((f) => node.type.startsWith(f.prefix));
-    if (!family)
-        return undefined;
-    const key = node.type.slice(family.prefix.length);
-    const def = runDefs.get(`${node.type}@${node.typeVersion}`) ?? runDefs.get(node.type);
-    const values = (def?.model?.bindings?.values ?? []);
-    const binding = (name) => {
-        const row = values.find((v) => v.name === name);
-        return typeof row?.default === 'string' ? row.default : undefined;
-    };
-    // The binding pair is the identity the runtime resolves by; without a
-    // definition to read there is nothing to recover it from.
-    const name = binding('name');
-    const folderPath = binding('folderPath');
-    // A sibling project of the same solution (#951): the model names its project
-    // instead of a folder. `isInSolution` is flow-core's marker; an in-solution
-    // agent emitted before #951 carries only `projectId`. Read back as
-    // `location: 'in-solution'` so the recompile takes the in-solution path
-    // instead of a published one with an empty folder.
-    const projectId = typeof def?.model?.projectId === 'string' ? def.model.projectId : undefined;
-    const inSolution = def?.model?.isInSolution === true || projectId !== undefined;
-    const inputs = { ...(node.inputs ?? {}) };
-    // The design-time fire-and-forget switch is an OPTION on the factory, not a
-    // process argument — serialize adds it to `inputs` after rendering the
-    // author's map, so it comes back off here.
-    const fireAndForget = unwrapPlain(inputs.fireAndForget) === true;
-    delete inputs.fireAndForget;
-    if (family.factory === 'agent' && (def?.model?.isInSolution === true || def?.model?.projectId !== undefined)) {
-        for (const [k, v] of Object.entries(inputs))
-            inputs[k] = legacyAgentTemplateInput(v);
-    }
-    const inputRows = Object.entries(inputs)
-        .map(([k, v]) => [k, emitVal(v, imp, inputNames)]);
-    const schema = def?.outputDefinition?.output?.schema?.properties;
-    const returns = schema && Object.keys(schema).length > 0
-        ? objLit(Object.entries(schema).map(([k, v]) => [k, tsLiteral(String(v?.type ?? 'string'))]))
-        : undefined;
-    return `${imp.use(family.factory)}(${opts([
-        ['key', tsLiteral(key)],
-        ['name', name !== undefined ? tsLiteral(name) : undefined],
-        ['location', inSolution ? tsLiteral('in-solution') : undefined],
-        ['folderPath', !inSolution && folderPath !== undefined ? tsLiteral(folderPath) : undefined],
-        ['projectId', inSolution && projectId !== undefined ? tsLiteral(projectId) : undefined],
-        ['inputs', inputRows.length ? objLit(inputRows) : undefined],
-        ['returns', returns],
-        ['form', family.form !== undefined ? tsLiteral(family.form) : undefined],
-        ['completion', fireAndForget ? tsLiteral('fire-and-forget') : undefined],
-    ])})`;
-}
 function emitConnector(node, imp, inputNames, o) {
     const split = splitConnector(node.type);
     const detail = (node.inputs?.detail ?? {});
@@ -3084,13 +2285,24 @@ function layoutSeg(flow, nodes, edges) {
     // compile refuses the whole `.layout()`. So its entry, and any edge route that
     // ends at it, is left out and compile places the node itself.
     const renamed = (id) => runAbsorbed.has(id) && runAbsorbed.get(id) !== id;
+    // A resource attached to a node whose spec cannot carry it (a tool on a voice
+    // agent) is reached only over artifact edges, and no spec folded it in: the
+    // source has no spelling for it, so the recompiled flow has no such node, and
+    // a layout entry for it would make compile refuse the whole `.layout()`.
+    const incoming = new Map();
+    for (const e of edges)
+        (incoming.get(e.targetNodeId) ?? incoming.set(e.targetNodeId, []).get(e.targetNodeId)).push(e);
+    const unspelled = (id) => {
+        const ins = incoming.get(id) ?? [];
+        return ins.length > 0 && !runAbsorbed.has(id) && ins.every((e) => ARTIFACT_PORTS.has(e.sourcePort));
+    };
     const nodeEntries = [];
     for (const n of nodes) {
         // A sticky note carries its own geometry in `.stickyNotes()`; a layout entry
         // for it would be a second, competing source for the same coordinates.
         if (n.type === STICKY_NOTE_TYPE)
             continue;
-        if (renamed(n.id))
+        if (renamed(n.id) || unspelled(n.id))
             continue;
         const ui = { ...(n.ui ?? {}), ...(hoisted[n.id] ?? {}) };
         const pos = ui.position;
@@ -3128,7 +2340,7 @@ function layoutSeg(flow, nodes, edges) {
         }
         if (!parts.length)
             continue;
-        if (renamed(e.sourceNodeId) || renamed(e.targetNodeId))
+        if (renamed(e.sourceNodeId) || renamed(e.targetNodeId) || unspelled(e.targetNodeId))
             continue;
         const pair = `${e.sourceNodeId}->${e.targetNodeId}`;
         if ((pairCount.get(pair) ?? 0) !== 1)