@uipath/maestro-builder-sdk 6.31.6 → 6.31.8

package/dist/check.js

@@ -10,7 +10,7 @@ import { FlowNode } from './core/node-classes.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { actionVersion, bundledActionNodeType, bundledContainerDefinition, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
-import { FORM_FIELD_TYPES, formFieldTypeHint, formFieldTypeWhy } from './core/form-field-type.js';
+import { FORM_FIELD_TYPES, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText } from './core/form-field-type.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
 import { checkCookedEscapes } from './flow-expr-check.js';
@@ -3416,7 +3416,7 @@ function checkInlineAgent(step, inputs, diags, opts = {}) {
                 if (!FORM_FIELD_TYPES.includes(String(f?.type))) {
                     at('INLINE_AGENT_ESCALATION_FIELD_TYPE_UNKNOWN', `Inline agent step "${step}"'s quick-form escalation gives the field "${String(f?.id ?? '?')}" the type `
                         + `${JSON.stringify(f?.type)}, ${formFieldTypeWhy(f?.type, `which the form does not recognize — it would `
-                            + `be published as a plain string`)}. Valid: ${FORM_FIELD_TYPES.join(', ')}.`, formFieldTypeHint(f?.type));
+                            + `be published as a plain string`)}. Valid: ${validFormFieldTypesText()}.`, formFieldTypeHint(f?.type));
                 }
             }
             continue;

package/dist/core/actions.d.ts

@@ -55,11 +55,22 @@ export interface ConnectorOpts {
     object?: string;
 }
 /**
- * A form field's type. The platform does not recognize a type outside this set:
- * older runtimes read it as text (so a number field becomes a text box), newer
- * ones reject the form. That is why `check` rejects anything outside this set.
+ * The platform's 11 canonical quick-form field types (`@uipath/hitl-schema-types`
+ * `fieldType`), which the designer saves. Each has its own value shape:
+ * `integer` → a JSON integer, `date` → `'2026-10-15'`, `datetime` → an ISO
+ * date-time, `file` → a binary-format string, `object` / `array` → JSON.
  */
-export type FormFieldType = 'text' | 'number' | 'boolean' | 'date-time';
+export type CanonicalFormFieldType = 'string' | 'number' | 'integer' | 'float' | 'double' | 'boolean' | 'date' | 'datetime' | 'file' | 'object' | 'array';
+/**
+ * A form field's type: one of the platform's canonical types, or `'text'` /
+ * `'date-time'`, the SDK's older spellings of `'string'` / `'datetime'` (the
+ * platform resolves both). A quick form with any other type fails the
+ * platform's validation, which is why `check` rejects it.
+ *
+ * @example
+ * hitl({ fields: [{ id: 'dueOn', type: 'date', direction: 'output' }], outcomes: ['Done'] })
+ */
+export type FormFieldType = CanonicalFormFieldType | 'text' | 'date-time';
 /** A value the reviewer READS: shown on the form, filled in from the flow. */
 export interface ShownField {
     /** Field id — the key the answer object uses. Must be unique on the form. */

package/dist/core/form-field-type.d.ts

@@ -1,49 +1,94 @@
 /**
- * The product's spellings of the form-field types the SDK models.
+ * The quick-form field-type vocabulary: the product's own, transcribed.
  *
  * A quick form's field `type` is read by the product through
- * `@uipath/hitl-schema-types` `normalizeFieldType`. Its canonical stored values
- * are `string`, `number`, `boolean`, `datetime`, … and it accepts aliases for
- * each: `text` is an alias of `string`, `date-time` of `datetime`, and .NET
- * names such as `System.String` resolve too. The designer saves the canonical
- * value, so a canvas-built form says `"string"`; the SDK (like flow-v1's
- * serializer and `uip maestro flow hitl add`) writes `text`.
+ * `@uipath/hitl-schema-types` (`fieldType`, `resolveFieldType`,
+ * `FIELD_TYPE_TO_JSON_SCHEMA`). It has 11 canonical stored values — `string`,
+ * `number`, `integer`, `float`, `double`, `boolean`, `date`, `datetime`, `file`,
+ * `object`, `array` — and it resolves aliases onto them: `text` is a legacy
+ * alias of `string`, `date-time` of `datetime`, and .NET names such as
+ * `System.Int32` resolve too. A `quick` form whose type resolves to none of the
+ * 11 fails the product's validation.
  *
- * So `"string"` and `"text"` are the same field on the wire. This table maps
- * each product spelling of the four types {@link FormFieldType} models to the
- * SDK's spelling, so decompile hands the author source `check` accepts.
- * A type the SDK does not model (`integer`, `date`,
- * `file`, …) has no entry: it stays as written, and `check` reports it.
+ * That package is published only to GitHub Packages, so the SDK cannot depend
+ * on it at runtime. This module is a transcription, and
+ * `tests/hitl-field-type-contract.test.ts` runs the real package against it:
+ * the canonical set, each type's JSON Schema, and every alias below must agree
+ * with the pinned `@uipath/hitl-schema-types`. A canonical-set or JSON Schema
+ * change upstream fails there; a new alias does not. The test also pins how the
+ * package resolves the spellings this module leaves out, so a change in those
+ * shows up.
  *
- * Mirrors `resolveFieldType` in `@uipath/hitl-schema-types` 1.1.6, restricted
- * to the groups that resolve to `string`, `number`, `boolean` and `datetime`
- * (minus `singleSelect` / `enum` / `union` / …, which resolve to `string` but
- * are not a plain text box).
+ * Every SDK path reads field types from here: `check` (human tasks and inline
+ * agent quick-form escalations), decompile, and the serializers' output
+ * schemas.
  */
-import type { FormFieldType } from './actions.js';
+import type { CanonicalFormFieldType } from './actions.js';
+/** The product's 11 canonical quick-form field types, in its own order. */
+export declare const CANONICAL_FORM_FIELD_TYPES: CanonicalFormFieldType[];
+/** The SDK's legacy spellings (`text`, `date-time`), for diagnostics that list them. */
+export declare const LEGACY_FORM_FIELD_TYPES: string[];
+/** Every form-field type the SDK accepts in source: the 11 canonical ones and the SDK's legacy aliases. */
+export declare const FORM_FIELD_TYPES: string[];
+/**
+ * The tail of a "Valid: …" diagnostic: the canonical types, then the legacy
+ * spellings in parentheses.
+ *
+ * @example
+ * validFormFieldTypesText() // 'string, number, …, array (or the older text, date-time)'
+ */
+export declare function validFormFieldTypesText(): string;
+/** The product aliases, for the contract test. */
+export declare const FORM_FIELD_TYPE_ALIASES: Readonly<Record<string, CanonicalFormFieldType>>;
+/**
+ * The canonical type a wire or source spelling names, or `undefined` when it
+ * names none the SDK models.
+ *
+ * @example
+ * canonicalFormFieldType('integer')      // 'integer'
+ * canonicalFormFieldType('text')         // 'string'
+ * canonicalFormFieldType('System.Int32') // 'integer'
+ * canonicalFormFieldType('string[]')     // 'array'
+ * canonicalFormFieldType('string | null') // 'string'
+ * canonicalFormFieldType('singleSelect') // undefined
+ */
+export declare function canonicalFormFieldType(type: unknown): CanonicalFormFieldType | undefined;
 /**
- * The SDK's spelling of a wire form-field type, or `undefined` when the SDK
- * does not model that type.
+ * The spelling decompile writes into source for a wire field type: a canonical
+ * type or an SDK alias stays as written, so a canvas form (`"integer"`,
+ * `"date"`) and a classic-CLI form (`"text"`) both compile back to the bytes
+ * they came from; a product alias the SDK does not accept in source
+ * (`"System.Int32"`, `"string[]"`) becomes its canonical type; anything else
+ * stays verbatim for `check` to report.
  *
  * @example
- * sdkFormFieldType('string')   // 'text'
- * sdkFormFieldType('datetime') // 'date-time'
- * sdkFormFieldType('integer')  // undefined
+ * sourceFormFieldType('date')          // 'date'
+ * sourceFormFieldType('text')          // 'text'
+ * sourceFormFieldType('System.String') // 'string'
+ * sourceFormFieldType('string[]')      // 'array'
+ * sourceFormFieldType('singleSelect')  // 'singleSelect'
  */
-export declare function sdkFormFieldType(wire: unknown): FormFieldType | undefined;
+export declare function sourceFormFieldType(wire: unknown): string;
 /**
- * Why a form-field type is refused: a product spelling of a type the SDK
- * models (`"string"` is the platform's own name for text), or a type
- * the SDK does not model at all. `unknownWhy` is the caller's reason for the
- * second case; the default is a human task's.
+ * Why a form-field type is refused: a product alias the SDK does not accept in
+ * source (`"System.Int32"` is the platform's .NET name for `integer`), a control
+ * spelling the platform accepts but the SDK does not model yet
+ * (`"singleSelect"`), or a type the product does not recognize at all.
+ * `unknownWhy` is the caller's reason for the last case; the default is a human
+ * task's.
  */
 export declare function formFieldTypeWhy(type: unknown, unknownWhy?: string): string;
-/** The form-field types the SDK models. */
-export declare const FORM_FIELD_TYPES: string[];
-/** The `suggestion` for an unknown form-field type: the nearest valid one, else `type: 'text'`. */
+/** The `suggestion` for an unknown form-field type: its canonical type, the nearest valid one, else `type: 'string'`. */
 export declare function formFieldTypeHint(type: unknown): string;
-/** JSON-Schema type per form-field type, as flow-v1's form serializer maps them (quick-form escalations and human tasks). */
-export declare const FORM_FIELD_JSON_TYPE: Record<FormFieldType, {
+/**
+ * The JSON Schema of a field's value, for the output (and escalation input)
+ * schemas the serializers write; `undefined` for a type the SDK does not model.
+ *
+ * @example
+ * formFieldJsonSchema('date') // { type: 'string', format: 'date' }
+ * formFieldJsonSchema('text') // { type: 'string' }
+ */
+export declare function formFieldJsonSchema(type: unknown): {
     type: string;
     format?: string;
-}>;
+} | undefined;

package/dist/core/form-field-type.js

@@ -1,63 +1,197 @@
 import { nearestName } from './edit-distance.js';
-const PRODUCT_SPELLINGS = {
-    text: 'text',
-    string: 'text',
-    String: 'text',
-    'System.String': 'text',
-    'System.Char': 'text',
-    Char: 'text',
-    number: 'number',
+import { ownEntry } from './own-entry.js';
+/**
+ * Each canonical type's JSON Schema, as `FIELD_TYPE_TO_JSON_SCHEMA` gives it.
+ * `Record<CanonicalFormFieldType, …>` makes tsc refuse a missing or extra one.
+ * `float` and `double` are both `number`: JSON Schema has no precision; `file`
+ * is `format: 'binary'` (the OpenAPI convention for an upload).
+ */
+const CANONICAL_JSON_SCHEMA = {
+    string: { type: 'string' },
+    number: { type: 'number' },
+    integer: { type: 'integer' },
+    float: { type: 'number' },
+    double: { type: 'number' },
+    boolean: { type: 'boolean' },
+    date: { type: 'string', format: 'date' },
+    datetime: { type: 'string', format: 'date-time' },
+    file: { type: 'string', format: 'binary' },
+    object: { type: 'object' },
+    array: { type: 'array' },
+};
+/** The product's 11 canonical quick-form field types, in its own order. */
+export const CANONICAL_FORM_FIELD_TYPES = Object.keys(CANONICAL_JSON_SCHEMA);
+/**
+ * The SDK's own legacy spellings, accepted in source: `text` (what the SDK,
+ * flow-v1's serializer and `uip maestro flow hitl add` have always written) and
+ * `date-time`. The product resolves both.
+ */
+const SDK_ALIASES = {
+    text: 'string',
+    'date-time': 'datetime',
+};
+/** The SDK's legacy spellings (`text`, `date-time`), for diagnostics that list them. */
+export const LEGACY_FORM_FIELD_TYPES = Object.keys(SDK_ALIASES);
+/** Every form-field type the SDK accepts in source: the 11 canonical ones and the SDK's legacy aliases. */
+export const FORM_FIELD_TYPES = [...CANONICAL_FORM_FIELD_TYPES, ...LEGACY_FORM_FIELD_TYPES];
+/**
+ * The tail of a "Valid: …" diagnostic: the canonical types, then the legacy
+ * spellings in parentheses.
+ *
+ * @example
+ * validFormFieldTypesText() // 'string, number, …, array (or the older text, date-time)'
+ */
+export function validFormFieldTypesText() {
+    return `${CANONICAL_FORM_FIELD_TYPES.join(', ')} (or the older ${LEGACY_FORM_FIELD_TYPES.join(', ')})`;
+}
+/**
+ * The product's other data-type spellings, each with the canonical type it
+ * resolves to (`resolveFieldType` in `@uipath/hitl-schema-types` 1.2.0). The
+ * .NET names come from forms built by RPA / agent tooling. The scope-walker
+ * shapes (`union`, `intersection`, `ref`, `any`) reach `field.type` when a
+ * canvas author binds a Flow variable; they carry no narrower shape, so they
+ * resolve to `string`. `T[]` and `a | b` are matched by pattern in
+ * `canonicalFormFieldType`.
+ *
+ * Deliberately left out: the CONTROL spellings `singleSelect`, `multiSelect`
+ * and `enum` (`CONTROL_FORM_FIELD_TYPES`). The product infers a `controlType`
+ * from those, so rewriting one to its data type would change how the form
+ * renders. Decompile keeps them as written, and `check` reports them.
+ */
+const PRODUCT_ALIASES = {
+    ...SDK_ALIASES,
+    String: 'string',
+    'System.String': 'string',
+    'System.Char': 'string',
+    Char: 'string',
     Number: 'number',
-    boolean: 'boolean',
+    Int32: 'integer',
+    Int64: 'integer',
+    'System.Int32': 'integer',
+    'System.Int64': 'integer',
+    'System.Byte': 'integer',
+    'System.Int16': 'integer',
+    Byte: 'integer',
+    Int16: 'integer',
+    UInt16: 'integer',
+    UInt32: 'integer',
+    UInt64: 'integer',
+    Float: 'float',
+    Single: 'float',
+    'System.Single': 'float',
+    Double: 'double',
+    Decimal: 'double',
+    'System.Double': 'double',
+    'System.Decimal': 'double',
     Boolean: 'boolean',
     'System.Boolean': 'boolean',
-    'date-time': 'date-time',
-    datetime: 'date-time',
-    dateTime: 'date-time',
-    DateTime: 'date-time',
-    'System.DateTime': 'date-time',
+    Date: 'date',
+    'System.DateOnly': 'date',
+    DateOnly: 'date',
+    dateTime: 'datetime',
+    DateTime: 'datetime',
+    'System.DateTime': 'datetime',
+    File: 'file',
+    Object: 'object',
+    DataTable: 'object',
+    QueueItem: 'object',
+    Array: 'array',
+    GenericValue: 'array',
+    list: 'array',
+    List: 'array',
+    union: 'string',
+    intersection: 'string',
+    ref: 'string',
+    any: 'string',
 };
 /**
- * The SDK's spelling of a wire form-field type, or `undefined` when the SDK
- * does not model that type.
+ * The product's control spellings: it accepts them as a field `type` and infers
+ * a picker control from them (`CONTROL_FOR_DECLARED_TYPE`). The SDK does not
+ * model them yet.
+ */
+const CONTROL_FORM_FIELD_TYPES = ['singleSelect', 'multiSelect', 'enum'];
+/** The product aliases, for the contract test. */
+export const FORM_FIELD_TYPE_ALIASES = PRODUCT_ALIASES;
+const isCanonical = (t) => typeof t === 'string' && Object.hasOwn(CANONICAL_JSON_SCHEMA, t);
+/**
+ * The canonical type a wire or source spelling names, or `undefined` when it
+ * names none the SDK models.
+ *
+ * @example
+ * canonicalFormFieldType('integer')      // 'integer'
+ * canonicalFormFieldType('text')         // 'string'
+ * canonicalFormFieldType('System.Int32') // 'integer'
+ * canonicalFormFieldType('string[]')     // 'array'
+ * canonicalFormFieldType('string | null') // 'string'
+ * canonicalFormFieldType('singleSelect') // undefined
+ */
+export function canonicalFormFieldType(type) {
+    if (isCanonical(type))
+        return type;
+    if (typeof type !== 'string')
+        return undefined;
+    // The package's own order: the two scope-walker patterns before the names.
+    if (type.endsWith('[]'))
+        return 'array';
+    if (type.includes(' | '))
+        return 'string';
+    return Object.hasOwn(PRODUCT_ALIASES, type) ? PRODUCT_ALIASES[type] : undefined;
+}
+/**
+ * The spelling decompile writes into source for a wire field type: a canonical
+ * type or an SDK alias stays as written, so a canvas form (`"integer"`,
+ * `"date"`) and a classic-CLI form (`"text"`) both compile back to the bytes
+ * they came from; a product alias the SDK does not accept in source
+ * (`"System.Int32"`, `"string[]"`) becomes its canonical type; anything else
+ * stays verbatim for `check` to report.
  *
  * @example
- * sdkFormFieldType('string')   // 'text'
- * sdkFormFieldType('datetime') // 'date-time'
- * sdkFormFieldType('integer')  // undefined
+ * sourceFormFieldType('date')          // 'date'
+ * sourceFormFieldType('text')          // 'text'
+ * sourceFormFieldType('System.String') // 'string'
+ * sourceFormFieldType('string[]')      // 'array'
+ * sourceFormFieldType('singleSelect')  // 'singleSelect'
  */
-export function sdkFormFieldType(wire) {
-    return typeof wire === 'string' && Object.hasOwn(PRODUCT_SPELLINGS, wire) ? PRODUCT_SPELLINGS[wire] : undefined;
+export function sourceFormFieldType(wire) {
+    if (typeof wire === 'string' && FORM_FIELD_TYPES.includes(wire))
+        return wire;
+    return canonicalFormFieldType(wire) ?? String(wire);
 }
 /**
- * Why a form-field type is refused: a product spelling of a type the SDK
- * models (`"string"` is the platform's own name for text), or a type
- * the SDK does not model at all. `unknownWhy` is the caller's reason for the
- * second case; the default is a human task's.
- */
-export function formFieldTypeWhy(type, unknownWhy = `which the platform does not recognize. Older runtimes read it as text, newer ones reject `
-    + `the form`) {
-    const alias = sdkFormFieldType(type);
-    return alias !== undefined
-        ? `which is the platform's spelling of the SDK's '${alias}' — the SDK writes '${alias}'`
-        : unknownWhy;
+ * Why a form-field type is refused: a product alias the SDK does not accept in
+ * source (`"System.Int32"` is the platform's .NET name for `integer`), a control
+ * spelling the platform accepts but the SDK does not model yet
+ * (`"singleSelect"`), or a type the product does not recognize at all.
+ * `unknownWhy` is the caller's reason for the last case; the default is a human
+ * task's.
+ */
+export function formFieldTypeWhy(type, unknownWhy = `which is not a quick-form field type: the platform rejects the form`) {
+    const canonical = canonicalFormFieldType(type);
+    if (canonical !== undefined)
+        return `which is the platform's alias of '${canonical}' — the SDK writes '${canonical}'`;
+    if (typeof type === 'string' && CONTROL_FORM_FIELD_TYPES.includes(type)) {
+        return `which the platform accepts as a picker control but the SDK does not model yet`;
+    }
+    return unknownWhy;
 }
-/** Every FormFieldType, once; `Record<FormFieldType, …>` makes tsc refuse a missing or extra one. */
-const FORM_FIELD_TYPE_SET = { text: true, number: true, boolean: true, 'date-time': true };
-/** The form-field types the SDK models. */
-export const FORM_FIELD_TYPES = Object.keys(FORM_FIELD_TYPE_SET);
-/** The `suggestion` for an unknown form-field type: the nearest valid one, else `type: 'text'`. */
+/** The `suggestion` for an unknown form-field type: its canonical type, the nearest valid one, else `type: 'string'`. */
 export function formFieldTypeHint(type) {
-    const alias = sdkFormFieldType(type);
-    if (alias !== undefined)
-        return `type: '${alias}'`;
+    const canonical = canonicalFormFieldType(type);
+    if (canonical !== undefined)
+        return `type: '${canonical}'`;
     const nearest = nearestName(String(type), FORM_FIELD_TYPES);
-    return nearest !== undefined ? `type: '${nearest}'` : `type: 'text'`;
+    return nearest !== undefined ? `type: '${nearest}'` : `type: 'string'`;
+}
+/**
+ * The JSON Schema of a field's value, for the output (and escalation input)
+ * schemas the serializers write; `undefined` for a type the SDK does not model.
+ *
+ * @example
+ * formFieldJsonSchema('date') // { type: 'string', format: 'date' }
+ * formFieldJsonSchema('text') // { type: 'string' }
+ */
+export function formFieldJsonSchema(type) {
+    const canonical = canonicalFormFieldType(type);
+    const schema = canonical === undefined ? undefined : ownEntry(CANONICAL_JSON_SCHEMA, canonical);
+    return schema === undefined ? undefined : { ...schema };
 }
-/** JSON-Schema type per form-field type, as flow-v1's form serializer maps them (quick-form escalations and human tasks). */
-export const FORM_FIELD_JSON_TYPE = {
-    text: { type: 'string' },
-    number: { type: 'number' },
-    boolean: { type: 'boolean' },
-    'date-time': { type: 'string', format: 'date-time' },
-};

package/dist/decompile.js

@@ -50,7 +50,7 @@ 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 { sdkFormFieldType } from './core/form-field-type.js';
+import { 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
@@ -1304,7 +1304,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['description', rPlain(e, 'description') !== undefined ? tsLiteral(rPlain(e, 'description')) : undefined],
             ['fields', rows.length ? `[${rows.map((f) => opts([
                     ['id', tsText(f.id)],
-                    ['type', tsLiteral(sdkFormFieldType(f.type ?? 'text') ?? String(f.type))],
+                    ['type', tsLiteral(sourceFormFieldType(f.type ?? 'string'))],
                     ['direction', tsLiteral(String(f.direction ?? 'output'))],
                 ])).join(', ')}]` : undefined],
             ['app', app === undefined ? undefined : opts([

package/dist/merge-embedded-agent.d.ts

@@ -0,0 +1,90 @@
+/**
+ * merge-embedded-agent — keep an EMBEDDED agent embedded when a brownfield edit
+ * touches it (flow-builder-sdk#1220).
+ *
+ * An agent node stores its configuration (prompts, model, run settings) in one
+ * of two places:
+ *
+ *   - embedded: on the node itself (`inputs.systemPrompt`, `inputs.model`, …).
+ *     Older Studio Web saves, and any save with the self-contained flag on.
+ *   - shell: the node keeps only its structural keys (`source`,
+ *     `agentInputVariables`, `agentOutputVariables`, …) and the configuration
+ *     lives in `<source>/agent.json`.
+ *
+ * The runtime and Studio Web pick the copy by `hasEmbeddedAgentContent`
+ * (`@uipath/flow-schema`): any prompt string on the node makes the node win and
+ * the sidecar is never read. Since #927 compile emits only shells. So when an
+ * edit changed an embedded agent's node (an input, an output, the label), the
+ * old merge took the edited SHELL node whole, and the agent's storage form
+ * flipped: the runtime then read the project's `<source>/agent.json`, which an
+ * embedded node had been shadowing and which is often stale. On corpus fixture
+ * `01-agent-input-binding` that silently changed the model from
+ * `gpt-4o-2024-11-20` to `gpt-5.4` and emptied the system prompt.
+ *
+ * The rule here is the same delta rule merge applies everywhere: the original
+ * node, plus what the author changed (`edited` minus `baseline`). The baseline
+ * and the edited node are both shells, so the configuration keys never appear in
+ * that delta and stay exactly as the original has them. Only the structural
+ * keys the author changed are taken from the edit. Without a baseline (a two-way
+ * merge), the edited node is taken, and every key the original has that the
+ * shell does not (the configuration) is put back.
+ *
+ * A prompt or model edit in the source does NOT reach an embedded agent: it
+ * lands in the edited `<source>/agent.json`, which the embedded node shadows.
+ * Merge reports that ({@link embeddedAgentFindings}), and refuses under
+ * `strict` any merged node that would no longer carry the original's embedded
+ * configuration, or whose kept prompt names an input the node no longer
+ * declares.
+ */
+import type { MergeFinding } from './merge-roundtrip.js';
+interface AgentNode {
+    id: string;
+    type: string;
+    inputs?: Record<string, unknown>;
+    [k: string]: unknown;
+}
+/**
+ * Whether `node` is an agent whose configuration is on the node, by
+ * `@uipath/flow-schema`'s `hasEmbeddedAgentContent`: a prompt string, or, on
+ * the voice node only, a `voice` settings object.
+ */
+export declare function isEmbeddedAgent(node: {
+    type?: string;
+    inputs?: Record<string, unknown>;
+} | undefined): boolean;
+/**
+ * The merged node for an embedded original whose edited node is a shell: the
+ * original, plus the author's change to the node.
+ *
+ * @param orig - The original node (embedded).
+ * @param edited - The edited compile's node (a shell).
+ * @param base - The baseline compile's node, when the merge has a baseline.
+ * @returns The original node with the edit's changed structural inputs and changed top-level keys applied.
+ */
+export declare function mergeEmbeddedAgentNode<N extends AgentNode>(orig: N, edited: N, base: N | undefined): N;
+/**
+ * What a merged embedded agent needs said, per original embedded agent (root
+ * and subflows, matched by scope and node id):
+ *
+ * - `agent-storage` (refuses): the merged node no longer carries the original's
+ *   embedded configuration, so the runtime would read `<source>/agent.json`
+ *   instead — a model or prompt change the author never wrote.
+ * - `agent-prompt-input` (refuses): a kept prompt names `{{input.X}}` but the
+ *   merged node declares no input `X` (the edit removed or renamed it), so the
+ *   prompt would render the placeholder empty.
+ * - `agent-embedded-edit` (warns): the author edited the node; merge applied the
+ *   node change and kept the original's prompts, model and settings, so a
+ *   prompt or model edit in the source did not reach this agent.
+ *
+ * @param hasBaseline - Whether the merge had a baseline. Without one, merge
+ *   cannot tell the author's change from the round trip's, so the
+ *   `agent-embedded-edit` warning says the node may have been edited.
+ * @param scopes - Per scope (`''` = root, otherwise the subflow key): the original, merged and edited-node-ids.
+ */
+export declare function embeddedAgentFindings(hasBaseline: boolean, scopes: Array<{
+    scope: string;
+    original: AgentNode[];
+    merged: AgentNode[];
+    edited: ReadonlySet<string>;
+}>): MergeFinding[];
+export {};