@uipath/maestro-builder-sdk 6.14.4 → 6.15.0

package/dist/serialize.js

@@ -23,7 +23,23 @@ import { declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
 import { buildConfiguration, transportHttpMethod } from './config.js';
 import { stableId } from './core/stable-id.js';
-import { readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf } from './event-filters.js';
+import { readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf } from './core/event-filters.js';
+import { FLOW_EXPR_DIALECT } from './core/connector-checks.js';
+import { buildConnectorInputs, connectorInputErrors as coreConnectorInputErrors, multipartBodyFieldName } from './core/connector-inputs.js';
+/**
+ * What `compile` would refuse these connector inputs with, or `undefined` when it
+ * would accept them — Flow's binding of the shared validator.
+ *
+ * `render` is not optional here: `renderDeep` is what REFUSES a lookup token in a
+ * position no lookup is resolved from (inside an opaque `object` input, say), and
+ * dropping it would make `check` quietly accept what `compile` throws on.
+ */
+export function connectorInputErrors(rc, inputs, resolutions = {}, lookups = {}) {
+    return coreConnectorInputErrors(rc, inputs, resolutions, lookups, {
+        dialect: FLOW_EXPR_DIALECT,
+        render: (value) => renderDeep(value, NO_RENAME),
+    });
+}
 import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './core/lookups.js';
 import { declaredScriptShape, inferScriptShape } from './core/script-return.js';
 import { migrateToSchemaVersion } from './migrate.js';
@@ -980,8 +996,9 @@ const TOOL_RESOURCE_TYPE = {
  *
  *  * `ixp`, `clientside` — measured to fail exactly that way (`ixp` leaves the
  *    flow failing validate; `clientside` drops the four inputs its node needs).
- *  * `connector` — `uip agent refresh` GENERATES it from the flow's connector
- *    node, reconstructing a whole `properties` block the SDK should not duplicate.
+ *  * `connector` — has its own writer, {@link connectorToolResourceJson}: its
+ *    node carries the configuration in `inputs.detail`, which the strip keeps,
+ *    and the file is the one `uip agent refresh` itself derives from it.
  *  * `mcp`, `a2a` — need the server's `availableTools` and the remote agent's
  *    card, which are tenant reads.
  *  * `builtin`, `httpRequest` — need a `properties.toolType` that maps
@@ -1202,6 +1219,225 @@ function connectorToolDef(rc) {
         inputDefaults: {},
     };
 }
+/** The folder key a connection with no folder binding carries in its resource.json. */
+const NO_FOLDER_KEY = '00000000-0000-0000-0000-000000000000';
+/**
+ * The library's operation description without the `(<Connector Name>) ` prefix
+ * the v1def's `display.description` carries — the model reads this text, and
+ * the designer's own resource.json has the bare sentence.
+ */
+function connectorToolDescription(rc) {
+    const text = String(rc.v1def?.display?.description ?? rc.entry?.display?.description ?? '');
+    const prefix = `(${rc.connectorName}) `;
+    return rc.connectorName && text.startsWith(prefix) ? text.slice(prefix.length) : text;
+}
+/** An agent-decided value: `{{prompt: "<what the model is told>"}}`. */
+function promptChip(f) {
+    const text = f.description || f.displayName || f.name;
+    return `{{prompt: "${text.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"}}`;
+}
+const isPromptChip = (v) => typeof v === 'string' && v.startsWith('{{prompt');
+/** The text inside `{{prompt: "…"}}`, unescaped; `''` for a bare `{{prompt}}`. */
+function chipText(value) {
+    const m = /\{\{\s*prompt:\s*"((?:[^"\\]|\\.)*)"/.exec(value);
+    return m ? m[1].replace(/\\(.)/g, '$1') : '';
+}
+/** A field's enum as `{ name, value }` rows, the platform's spelling; `undefined` when it has none. */
+function enumRows(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    return raw.map((e) => (typeof e === 'string'
+        ? { name: e, value: e }
+        : { name: String(e?.name ?? e?.value ?? ''), value: String(e?.value ?? e?.name ?? '') }));
+}
+/**
+ * The `inputs.detail` of a connector-tool node — the same key set a
+ * `connector()` step's node carries, with the request buckets filled the way
+ * `uip maestro flow node configure` fills them for a `tool.connector.*` node
+ * (uipcli `buildAgentToolParamsFromMetadata`): every BODY field is
+ * agent-decided (`{{prompt: "<description>"}}`) except a single-value enum,
+ * which is its one constant (the model would otherwise guess — `google` for
+ * `GoogleCustomSearch`); a QUERY/PATH parameter with a declared default sends
+ * it, and otherwise is agent-decided too.
+ */
+function connectorToolDetail(rc, conn, folder, seed) {
+    const params = Array.isArray(rc.entry?.operation?.parameters) ? rc.entry.operation.parameters : [];
+    const buckets = { body: {}, query: {}, path: {} };
+    for (const f of rc.fields ?? []) {
+        const loc = f.location ?? 'body';
+        if (loc === 'body') {
+            const only = enumRows(f.enum);
+            buckets.body[f.name] = only && only.length === 1 ? only[0].value : promptChip(f);
+        }
+        else if (loc === 'query' || loc === 'path') {
+            const dflt = params.find((p) => p?.name === f.name)?.defaultValue;
+            buckets[loc][f.name] = dflt !== undefined && dflt !== null && dflt !== '' ? dflt : promptChip(f);
+        }
+    }
+    const parts = rc.multipartParts ?? [];
+    return {
+        connector: rc.connectorKey,
+        method: transportHttpMethod(rc.httpMethod),
+        endpoint: rc.endpoint,
+        ...(rc.objectName ? { objectName: rc.objectName } : {}),
+        inputMetadata: parts.length
+            ? { type: 'multipart', multipart: { bodyFieldName: multipartBodyFieldName(parts) } }
+            : {},
+        errorState: { hasError: false },
+        telemetryData: { connectorKey: rc.connectorKey, connectorName: rc.connectorName },
+        configuration: buildConfiguration(rc.entry, rc.version, {}, seed),
+        ...(rc.activityTypeId ? { uiPathActivityTypeId: rc.activityTypeId } : {}),
+        ...(conn ? { connectionId: conn, connectionResourceId: conn } : {}),
+        ...(folder ? { connectionFolderKey: folder } : {}),
+        bodyParameters: buckets.body,
+        ...(Object.keys(buckets.path).length ? { pathParameters: buckets.path } : {}),
+        ...(Object.keys(buckets.query).length ? { queryParameters: buckets.query } : {}),
+        ...(parts.length ? { multipartParameters: parts.map((p) => ({ name: p.name, dataType: p.dataType })) } : {}),
+    };
+}
+/** Walk (creating) the object chain for a dotted field name; returns the parent schema and the leaf key. */
+function nestedSlot(root, name) {
+    const segments = name.split('.');
+    let parent = root;
+    for (const seg of segments.slice(0, -1)) {
+        let child = parent.properties[seg];
+        if (!child || child.type !== 'object') {
+            child = { type: 'object', properties: {} };
+            parent.properties[seg] = child;
+        }
+        parent = child;
+    }
+    return { parent, leaf: segments[segments.length - 1] };
+}
+/**
+ * The `resources/<id>/resource.json` of a CONNECTOR tool (#867) — the file the
+ * agent runtime registers the tool from, and the one that puts the connection
+ * under the solution's Resources.
+ *
+ * The shape is uipcli's `mapConnectorToolToResource` (the writer behind `uip
+ * agent refresh --inline-in-flow`, itself ported from flow-workbench's
+ * `agent-connector-tool` mapper), in its metadata-enriched form: field types,
+ * enums, `required` and the response fields come from the curated library,
+ * which carries the same declarations that command fetches from Integration
+ * Service. Where that writer and a Studio Web export differ, this follows the
+ * writer: `enum`/`oneOf` only on agent-decided fields (a static field with an
+ * enum breaks the runtime's model build), no `additionalProperties`, and
+ * array-of-object response fields (`results[*]`) left out.
+ *
+ * The values come from the node's own `detail` — the same source refresh reads —
+ * so a later refresh rewrites this file to itself.
+ */
+function connectorToolResourceJson(ctx, id) {
+    const { rc, detail } = ctx;
+    const valueOf = (raw) => raw !== null && typeof raw === 'object' ? JSON.stringify(raw) : String(raw ?? '');
+    const bucketOf = { body: 'bodyParameters', query: 'queryParameters', path: 'pathParameters' };
+    const fields = [];
+    for (const f of rc.fields ?? []) {
+        const loc = f.location ?? 'body';
+        if (loc === 'multipart')
+            continue;
+        const value = valueOf(detail[bucketOf[loc]]?.[f.name]);
+        fields.push({
+            name: f.name,
+            fieldLocation: loc,
+            type: f.type || 'string',
+            ...(loc === 'body' && enumRows(f.enum)
+                ? { enumValues: enumRows(f.enum) } : {}),
+            required: f.required === true,
+            description: f.description ?? '',
+            ...(f.displayName ? { displayName: f.displayName } : {}),
+            value,
+            isPrompt: isPromptChip(value),
+        });
+    }
+    for (const part of (detail.multipartParameters ?? [])) {
+        fields.push({
+            name: part.name, fieldLocation: 'multipart', type: part.dataType || 'string',
+            required: false, description: '', value: '{{prompt}}', isPrompt: true,
+        });
+    }
+    const inputSchema = { type: 'object', properties: {} };
+    for (const f of fields) {
+        if (f.fieldLocation === 'multipart')
+            continue;
+        const { parent, leaf } = nestedSlot(inputSchema, f.name);
+        const prop = { type: f.type, title: f.displayName ?? leaf, description: f.description };
+        if (f.isPrompt && f.enumValues) {
+            prop.enum = f.enumValues.map((e) => e.value);
+            prop.oneOf = f.enumValues.map((e) => ({ const: e.value, title: e.name }));
+        }
+        parent.properties[leaf] = prop;
+        if (f.required)
+            (parent.required ??= []).push(leaf);
+    }
+    const outputSchema = { type: 'object', properties: {}, definitions: {} };
+    for (const f of (rc.entry?.outputSchema?.fields ?? [])) {
+        if (typeof f?.name !== 'string' || f.name.includes('[*]'))
+            continue;
+        const { parent, leaf } = nestedSlot(outputSchema, f.name);
+        parent.properties[leaf] = {
+            type: f.type || 'string',
+            title: f.displayName ?? leaf,
+            ...(f.description ? { description: f.description } : {}),
+        };
+    }
+    const multipart = detail.inputMetadata?.type === 'multipart';
+    return {
+        $resourceType: 'tool',
+        name: ctx.name,
+        description: ctx.description,
+        location: 'external',
+        type: 'integration',
+        inputSchema,
+        outputSchema,
+        settings: {},
+        properties: {
+            toolPath: rc.endpoint ?? '',
+            objectName: rc.objectName ?? '',
+            toolDisplayName: ctx.name,
+            toolDescription: ctx.description,
+            // The operation KEY (`GETBYID` for a get-by-id), not the transport verb:
+            // the runtime sends it to Integration Service to pick the operation.
+            method: rc.httpMethod,
+            connection: {
+                id: detail.connectionId ?? '',
+                name: rc.connectorName,
+                elementInstanceId: 0,
+                apiBaseUri: '',
+                state: 'enabled',
+                isDefault: false,
+                connector: { key: rc.connectorKey, name: rc.connectorName, image: '' },
+                folder: { key: detail.connectionFolderKey ?? NO_FOLDER_KEY, path: '' },
+            },
+            parameters: fields.map((f, i) => ({
+                name: f.name,
+                displayName: f.displayName ?? f.name,
+                type: f.type,
+                fieldLocation: f.fieldLocation,
+                value: f.value,
+                // uipcli's fallback: an undescribed agent-decided field keeps the chip's own text.
+                description: f.description || (f.isPrompt ? chipText(f.value) : ''),
+                position: f.required ? 'primary' : 'secondary',
+                sortOrder: i + 1,
+                required: f.required,
+                fieldVariant: f.isPrompt ? 'dynamic' : 'static',
+                isCascading: false,
+                dynamic: f.isPrompt,
+                enumValues: f.enumValues ?? null,
+                loadReferenceOptionsByDefault: null,
+                dynamicBehavior: [],
+                reference: null,
+            })),
+            bodyStructure: multipart
+                ? { contentType: 'multipart', jsonBodySection: detail.inputMetadata.multipart?.bodyFieldName ?? 'body' }
+                : { contentType: 'json' },
+        },
+        guardrail: { policies: [] },
+        iconUrl: ctx.iconUrl,
+        id,
+        isEnabled: true,
+    };
+}
 /**
  * The tool kinds that wrap a DEPLOYED tenant resource, and everything that
  * differs between them. Transcribed from `registry get` over one live example
@@ -4434,12 +4670,16 @@ export function serialize(built, opts = {}) {
             const { entries: connBindings } = connectionResourceBindings({ def: rc.v1def, connectorKey: rc.connectorKey, connectionId: conn, folderKey: folder }, resourceBindings);
             for (const b of connBindings)
                 resourceBindings.set(b.id, b);
-            const connectorInputs = buildConnectorInputs(rc, spec.inputs, scope.rename, opts.library.lookupResolutions ?? {}, 
-            // Only for the missing-required hint; a test double that is not a full
-            // Library simply gets the plain message.
-            typeof opts.library.lookupSpecs === 'function'
-                ? opts.library.lookupSpecs(spec.key, spec.action, spec.version, spec.object)
-                : {});
+            const connectorInputs = buildConnectorInputs(rc, spec.inputs, {
+                dialect: FLOW_EXPR_DIALECT,
+                render: (value) => renderDeep(value, scope.rename),
+                resolutions: opts.library.lookupResolutions ?? {},
+                // Only for the missing-required hint; a test double that is not a full
+                // Library simply gets the plain message.
+                lookups: typeof opts.library.lookupSpecs === 'function'
+                    ? opts.library.lookupSpecs(spec.key, spec.action, spec.version, spec.object)
+                    : {},
+            });
             const replayInputs = {
                 ...(connectorInputs.bodyParameters ?? {}),
                 ...(connectorInputs.pathParameters ?? {}),
@@ -4712,6 +4952,7 @@ export function serialize(built, opts = {}) {
                 let tdef;
                 let label;
                 let extraInputs = {};
+                let connectorTool;
                 if (tr.kind === 'builtin') {
                     tdef = clone(BUILTIN_TOOL_DEFS[tr.tool]);
                     if (!tdef)
@@ -4754,10 +4995,33 @@ export function serialize(built, opts = {}) {
                     const rc = opts.library.resolve(tr.connector, tr.operation, tr.version, tr.object);
                     tdef = connectorToolDef(rc);
                     label = tr.name ?? rc.v1def?.display?.label ?? tr.operation;
-                    // The connector tool's configuration (connection, folder) is bound at
-                    // the agent/solution layer, not on the node: the deployed corpus
-                    // carries `inputs: {}` and a top-level `bindings: []` even for a
-                    // connector tool, so nothing is emitted here beyond the identity.
+                    // The connection rides the same three places it does for a
+                    // `connector()` step, because the platform reads it from the same
+                    // three (#867):
+                    //  * the node's `inputs.detail` — what `uip maestro flow node configure`
+                    //    writes on a `tool.connector.*` node, what `uip agent refresh
+                    //    --inline-in-flow` builds the tool's resource.json FROM, and what
+                    //    its shell-ify pass keeps ("where a connector tool's request config
+                    //    lives"). It is also what `bindings_v2.json` is derived from.
+                    //  * the top-level `bindings[]` pair the def's `model.context`
+                    //    placeholders (`<bindings.… connection>` / `<bindings.FolderKey>`)
+                    //    name.
+                    //  * the agent's `resources/<id>/resource.json` (below).
+                    // Emitting none of them left the tool with no connection anywhere.
+                    const where = `inline agent "${step.name}"'s connector tool "${tr.connector}/${tr.operation}"`;
+                    const target = { key: tr.connector, action: tr.operation };
+                    const conn = resolveBinding(opts, tr.connection, 'connection', where, target);
+                    const folder = resolveBinding(opts, tr.folder, 'folder', where, target);
+                    const { entries: connBindings } = connectionResourceBindings({ def: rc.v1def, connectorKey: rc.connectorKey, connectionId: conn, folderKey: folder }, resourceBindings);
+                    for (const b of connBindings)
+                        resourceBindings.set(b.id, b);
+                    const detail = connectorToolDetail(rc, conn, folder, `${step.name}Tool`);
+                    extraInputs = { detail };
+                    connectorTool = {
+                        rc, detail, name: label,
+                        description: tr.description ?? connectorToolDescription(rc),
+                        iconUrl: String(tdef.display?.icon ?? ''),
+                    };
                 }
                 else if (tr.kind === 'mcp') {
                     // Per-instance def minted like the ixp family's; the node carries the
@@ -4837,6 +5101,10 @@ export function serialize(built, opts = {}) {
                 const tid = uid(scope, `${step.name}Tool`);
                 const tnode = makeNode(tdef.nodeType, tid, label, { parentId, def: tdef });
                 tnode.display = { ...tnode.display, shape: 'circle' };
+                // `uip agent refresh` reads the tool's description off the node's display
+                // first, so the node carries the one the resource.json does.
+                if (connectorTool)
+                    tnode.display.description = connectorTool.description;
                 // The resource model lives on the DEFINITION only (CX's rule for
                 // context, and what the deployed corpus carries for tools).
                 delete tnode.model;
@@ -4855,8 +5123,10 @@ export function serialize(built, opts = {}) {
                 addEdge(scope, { node: id, port: 'tool' }, tid, 'input');
                 // The other half, for the kinds whose file is DERIVABLE — see
                 // `toolResourceJson` for which are not, and why each is left to the
-                // generator or the designer rather than guessed.
-                const toolResource = toolResourceJson(tr, { id: toolResourceId });
+                // designer rather than guessed.
+                const toolResource = connectorTool
+                    ? connectorToolResourceJson(connectorTool, toolResourceId)
+                    : toolResourceJson(tr, { id: toolResourceId });
                 if (toolResource !== undefined) {
                     sidecars.push({
                         path: `${source}/resources/${toolResourceId}/resource.json`,
@@ -6365,419 +6635,6 @@ export function assertBindingPlaceholdersResolve(flow) {
         + `"invalid GUID <bindings.…>") and refuses to publish. This is a serializer defect, not an authoring `
         + `error; report it with the flow source.`);
 }
-/**
- * Validate a connector's activity inputs against its declared field list and
- * return them ROUTED to the wire slots the platform reads. Catches the three
- * connector-input mistakes — missing required, unknown key, type mismatch — at
- * compile, where the author can act on them.
- *
- * Generated descriptors accept natural nested objects and arrays; the legacy
- * string form also accepts exact flat registry field ids. Routing remains the
- * library's business because a field's location is a property of the operation.
- * Each projected registry field lands in the slot its declaration names:
- *
- * ```jsonc
- * // connector('uipath-atlassian-jira','get-issue', { issueId: …, project: 'IN', issuetype: 'Task' })
- * "inputs": { "detail": {
- *   "endpoint":        "/curated_get_issue/{issueId}",
- *   "pathParameters":  { "issueId": "IN-28" },
- *   "queryParameters": { "project": "IN", "issuetype": "Task" },
- *   "bodyParameters":  {} } }
- * ```
- *
- * That is the platform's own encoding, measured on the deployed corpus: 1,283
- * connector nodes in the nightly artifacts, 384 carrying `pathParameters` and
- * 576 carrying `queryParameters`, always as a FLAT map keyed by the parameter's
- * DECLARED name (`send_as`, `issuetype`, `channel_id` keep their spelling — no
- * camelCasing) and always as a SIBLING of `bodyParameters` rather than as a
- * location-tagged entry inside it.
- */
-/** For a missing required lookup field: what it sends and how to resolve it. Empty for a plain field. */
-function missingLookupHint(field, lookup) {
-    if (!lookup)
-        return '';
-    const target = `${lookup.objectName ?? lookup.path}.${lookup.value}`;
-    const alias = Object.keys(lookup.aliases)[0];
-    const call = alias
-        ? `lookup(<Descriptor>, '${field}').${alias}('<value>')`
-        : `lookup(<Descriptor>, '${field}').by('${lookup.by[0] ?? 'id'}', '<value>')`;
-    return ` — a lookup id (\`${target}\`), not a name or address: ${call}`;
-}
-/**
- * What `compile` would refuse these connector inputs with, or `undefined` when it
- * would accept them — the SAME code path `buildConnectorInputs` runs at emit time,
- * so `check` and `compile` cannot disagree about a missing required field, an
- * unknown or mistyped input, or a container part passed as a value. Unresolved
- * lookups are the one thing skipped: `check` already reports them as
- * LOOKUP_UNRESOLVED with the resolution recipe.
- */
-export function connectorInputErrors(rc, inputs, resolutions = {}, lookups = {}) {
-    try {
-        buildConnectorInputs(rc, inputs, NO_RENAME, resolutions, lookups, { unresolvedLookups: 'ignore' });
-        return undefined;
-    }
-    catch (e) {
-        return e instanceof Error ? e.message : String(e);
-    }
-}
-function buildConnectorInputs(rc, inputs, rename = NO_RENAME, resolutions = {}, lookups = {}, policy = {}) {
-    const fields = (rc.fields ?? []);
-    const byName = new Map(fields.map((f) => [f.name, f]));
-    const errs = validateNestedConnectorKeys(fields, inputs, byName);
-    const routed = {
-        bodyParameters: {}, pathParameters: {}, queryParameters: {},
-    };
-    // The author's values for FILE parts, by part name. The part LIST itself comes
-    // from the library (`rc.multipartParts`): a string-typed part is a transport
-    // container the runtime composes from `bodyParameters`, so it is listed without
-    // a value and is never an author input — see `readFields` in core/library.ts.
-    const partValues = new Map();
-    for (const f of fields) {
-        const flat = Object.prototype.hasOwnProperty.call(inputs, f.name);
-        let nested = flat
-            ? { found: true, value: inputs[f.name], projectedArrays: 0 }
-            : readConnectorPath(inputs, f.name);
-        if (!nested.found) {
-            // A required LOOKUP field is missing far more often because the author does
-            // not know what to put in it than because they forgot it exists: name the
-            // id it sends and the helper that finds one, so "(string)" is not read as
-            // "any string" — an e-mail into `fields.reporter.id` is exactly that misreading.
-            if (f.required)
-                errs.push(`missing required input "${f.name}" (${f.type ?? 'value'})${missingLookupHint(f.name, lookups[f.name])}`);
-            continue;
-        }
-        // An unresolved lookup is swapped for its recorded id, or reported. It is
-        // NOT rendered as a placeholder: emitting something for a value nobody
-        // resolved would produce a flow that compiles and then talks to the wrong
-        // record, which is exactly the failure the lookup surface exists to remove.
-        //
-        // A token is swapped wherever the field's value can hold one: the whole
-        // value, or an element of an array at any depth. A multiselect is
-        // `users: [lookup(…), lookup(…)]` — the form `ConnectorLookupValue`'s array
-        // branch types and the generated `## Example` prints — and until this swapped
-        // only the whole-value case, so every token inside the array reached
-        // validation as an object ("expected string, got object") with every lookup
-        // recorded. An unresolved element under 'ignore' becomes `null`, which
-        // validation skips, so `check` still type-checks the resolved siblings.
-        const unresolved = [];
-        const swapped = swapLookupTokens(nested.value, resolutions, unresolved);
-        if (unresolved.length) {
-            if (policy.unresolvedLookups !== 'ignore') {
-                for (const token of unresolved)
-                    errs.push(unresolvedLookupMessage(token));
-                continue;
-            }
-            if (isLookupToken(nested.value))
-                continue;
-        }
-        nested = { ...nested, value: swapped };
-        // A FLAT key whose wire name ends in `[*]` names one array: an array value
-        // there is checked element by element, as the nested form is. A flat scalar
-        // keeps depth 0 and is emitted as the scalar it is — the product wraps it
-        // into a one-element list (flow-v1 `convertDotNotationToNested`).
-        const depth = flat
-            ? (f.name.endsWith('[*]') && Array.isArray(nested.value) ? 1 : 0)
-            : nested.projectedArrays;
-        validateConnectorFieldValue(f, nested.value, depth, errs);
-        if (f.location === 'multipart') {
-            partValues.set(f.name, renderDeep(nested.value, rename));
-            continue;
-        }
-        const slot = SLOT_FOR_LOCATION[f.location ?? 'body'] ?? 'bodyParameters';
-        routed[slot][f.name] = renderDeep(nested.value, rename);
-    }
-    if (errs.length) {
-        // Name the location of each required field: a "missing required input" on a
-        // path parameter reads very differently from one on a body field, and the
-        // author's fix is the same either way (add it to the same flat `inputs` map).
-        const req = fields
-            .filter((f) => f.required)
-            .map((f) => (f.location && f.location !== 'body' ? `${f.name} (${f.location})` : f.name))
-            .join(', ') || '(none required)';
-        // Phase 1 propagates connector discovery capability to every activity. When
-        // one of those activities rejects an unknown field, point at the live-schema
-        // preparation path; fully static activities on the same connector still
-        // compile normally and never reach this hint.
-        const schemaDynamic = !!rc.entry?.runtime?.requiresConnectionForSchema;
-        const hasUnknown = errs.some((e) => e.startsWith('unknown input'));
-        let hint = '';
-        if (schemaDynamic && hasUnknown) {
-            const prefix = `uipath.connector.${rc.connectorKey}.`;
-            const action = String(rc.nodeType).startsWith(prefix)
-                ? String(rc.nodeType).slice(prefix.length)
-                // `.pop()` on a split is never empty at runtime, but its type admits
-                // `undefined`; the node type itself is the only sane fallback.
-                : String(rc.nodeType).split('.').pop() ?? String(rc.nodeType);
-            hint =
-                ` This connector supports connection-specific object or field discovery, and the ` +
-                    `static library does not contain this input. Run ` +
-                    `\`${prepareCommand(rc.connectorKey, action)}\` ` +
-                    `to load them ` +
-                    `(writes ./.flow-sdk/connectors-local/, which the compiler auto-detects). If that still ` +
-                    `does not carry this input, the operation resolves its fields from the VALUES of ` +
-                    `parent inputs: resolve every parent and re-run with ` +
-                    `\`-f <parent-field>=<value>\` for each — too few parents is refused, and a ` +
-                    `wrong value resolves back to just the parents. ` +
-                    `See the connector guide's parent-field loop.`;
-        }
-        throw new Error(`connector ${rc.nodeType}: ${errs.join('; ')}. Required fields: ${req}.${hint}`);
-    }
-    // Every declared part, in declaration order, as the designer lists them: the
-    // container part valueless, a file part with the author's value when given. A
-    // test double that resolves no `multipartParts` falls back to its multipart
-    // fields, which are all file parts by construction.
-    const declaredParts = rc.multipartParts
-        ?? fields.filter((f) => f.location === 'multipart').map((f) => ({ name: f.name, dataType: f.type ?? 'string' }));
-    const multipartParameters = declaredParts.map((part) => (partValues.has(part.name)
-        ? { name: part.name, dataType: part.dataType, value: partValues.get(part.name) }
-        : { name: part.name, dataType: part.dataType }));
-    // A FIXED slot order, so a recompile is byte-identical no matter which order
-    // the author listed the inputs in.
-    const slots = multipartParameters.length === 0 || Object.keys(routed.bodyParameters).length > 0
-        ? { bodyParameters: routed.bodyParameters }
-        : {};
-    if (Object.keys(routed.pathParameters).length)
-        slots.pathParameters = routed.pathParameters;
-    if (Object.keys(routed.queryParameters).length)
-        slots.queryParameters = routed.queryParameters;
-    if (multipartParameters.length) {
-        slots.multipartParameters = multipartParameters;
-        slots.inputMetadata = { type: 'multipart', multipart: { bodyFieldName: multipartBodyFieldName(declaredParts) } };
-    }
-    return slots;
-}
-/**
- * `value` with every lookup token swapped for its recorded id: the value itself,
- * or the elements of an array at any depth. An unrecorded token is pushed to
- * `unresolved` and stands as `null`, so an array keeps its length.
- *
- * Objects are NOT descended: a lookup's place is a field's value or an element
- * of an array field (`ConnectorLookupValue`), and a nested path such as
- * `contacts[*].id` reaches here already projected to its leaf array. A token
- * anywhere else is refused by {@link renderDeep}.
- */
-function swapLookupTokens(value, resolutions, unresolved) {
-    if (isLookupToken(value)) {
-        const resolved = resolvedValue(value, resolutions);
-        if (resolved === undefined) {
-            unresolved.push(value);
-            return null;
-        }
-        return resolved;
-    }
-    if (Array.isArray(value))
-        return value.map((item) => swapLookupTokens(item, resolutions, unresolved));
-    return value;
-}
-/**
- * `inputMetadata.multipart.bodyFieldName` names the CONTAINER part — the one the
- * runtime composes from `bodyParameters`. Measured on the designer's own nodes in
- * the eval archive: `body` ×413, `RagRequest` ×1 (GenAI `content-generation`, whose
- * string part is named that), and `body` on 91 of 93 file-only operations. A
- * mis-named container is fatal at dispatch — hardcoding `body` for GenAI made
- * Integration Service answer `400 The request body is empty` (verified live
- * 2026-09-02) — so it is the string part's own name, with `body` only as the
- * default for an operation that has no string part.
- */
-function multipartBodyFieldName(parts) {
-    const containers = parts.filter((p) => p.dataType.toLowerCase() !== 'file');
-    return containers.length === 1 ? containers[0].name : 'body';
-}
-const SLOT_FOR_LOCATION = {
-    body: 'bodyParameters',
-    query: 'queryParameters',
-    path: 'pathParameters',
-};
-function connectorPath(name) {
-    return name.split('.').map((raw) => ({
-        key: raw.endsWith('[*]') ? raw.slice(0, -3) : raw,
-        array: raw.endsWith('[*]'),
-    }));
-}
-/** Read a natural nested authoring value using a registry path such as
- * `contacts[*].id`. Wildcards project one value per array element so the Flow
- * bodyParameters map can retain the registry's exact field ids. */
-function readConnectorPath(inputs, name) {
-    const parts = connectorPath(name);
-    const read = (value, index) => {
-        if (index >= parts.length)
-            return { found: true, value, projectedArrays: 0 };
-        if (!value || typeof value !== 'object' || value instanceof Expr || Array.isArray(value))
-            return { found: false, projectedArrays: 0 };
-        const part = parts[index];
-        const object = value;
-        if (!Object.prototype.hasOwnProperty.call(object, part.key))
-            return { found: false, projectedArrays: 0 };
-        const next = object[part.key];
-        if (!part.array)
-            return read(next, index + 1);
-        if (!Array.isArray(next))
-            return { found: false, projectedArrays: 0 };
-        if (index === parts.length - 1)
-            return { found: true, value: next, projectedArrays: 1 };
-        const projected = next.map((item) => read(item, index + 1));
-        if (!projected.some((item) => item.found))
-            return { found: false, projectedArrays: 0 };
-        return {
-            found: true,
-            value: projected.map((item) => item.found ? item.value : null),
-            projectedArrays: 1 + Math.max(0, ...projected.map((item) => item.projectedArrays)),
-        };
-    };
-    return read(inputs, 0);
-}
-function buildConnectorInputTrie(fields) {
-    const root = { children: new Map(), array: false };
-    for (const field of fields) {
-        let cursor = root;
-        for (const part of connectorPath(field.name)) {
-            let child = cursor.children.get(part.key);
-            if (!child) {
-                child = { children: new Map(), array: part.array };
-                cursor.children.set(part.key, child);
-            }
-            child.array ||= part.array;
-            cursor = child;
-        }
-        cursor.terminal = field;
-    }
-    return root;
-}
-/** Reject nested typos with the same unknown-key message as flat keys. */
-function validateNestedConnectorKeys(fields, inputs, exact) {
-    const root = buildConnectorInputTrie(fields);
-    const errs = [];
-    const visit = (value, node, path) => {
-        if (value instanceof Expr)
-            return;
-        if (node.array) {
-            if (!Array.isArray(value)) {
-                errs.push(`input "${path}" expected array, got ${typeof value}`);
-                return;
-            }
-            for (const item of value)
-                visit(item, { ...node, array: false }, `${path}[*]`);
-            return;
-        }
-        // An opaque object/array terminal owns its complete value; there is no
-        // child metadata with which to validate its internal keys.
-        if (node.terminal && node.children.size === 0)
-            return;
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            if (node.children.size > 0)
-                errs.push(`input "${path}" expected object, got ${Array.isArray(value) ? 'array' : typeof value}`);
-            return;
-        }
-        for (const [key, childValue] of Object.entries(value)) {
-            const child = node.children.get(key);
-            const childPath = path ? `${path}.${key}` : key;
-            if (!child) {
-                const near = nearestField(childPath, fields.map((f) => f.name));
-                errs.push(`unknown input "${childPath}"${near ? ` — did you mean "${near}"?` : ''}`);
-            }
-            else {
-                visit(childValue, child, childPath);
-            }
-        }
-    };
-    for (const [key, value] of Object.entries(inputs)) {
-        if (exact.has(key))
-            continue; // backwards-compatible flat authoring
-        const node = root.children.get(key);
-        if (!node) {
-            const near = nearestField(key, [...exact.keys()]);
-            errs.push(`unknown input "${key}"${near ? ` — did you mean "${near}"?` : ''}`);
-        }
-        else {
-            visit(value, node, key);
-        }
-    }
-    return errs;
-}
-function validateConnectorFieldValue(field, value, projectedArrays, errs) {
-    if (projectedArrays > 0) {
-        if (!Array.isArray(value)) {
-            errs.push(`input "${field.name}" expected array projection, got ${typeof value}`);
-            return;
-        }
-        for (const item of value) {
-            if (item !== null && item !== undefined)
-                validateConnectorFieldValue(field, item, projectedArrays - 1, errs);
-        }
-        return;
-    }
-    if (value instanceof Expr || value === null || value === undefined)
-        return;
-    if (field.type === 'array') {
-        if (!Array.isArray(value))
-            errs.push(`input "${field.name}" expected array, got ${typeof value}`);
-        return;
-    }
-    if (field.type === 'object') {
-        if (typeof value !== 'object' || Array.isArray(value))
-            errs.push(`input "${field.name}" expected object, got ${Array.isArray(value) ? 'array' : typeof value}`);
-        return;
-    }
-    if (field.type === 'string' || field.type === 'number' || field.type === 'boolean') {
-        const actual = typeof value;
-        const ok = actual === field.type ||
-            (field.type === 'number' && actual === 'string' && value !== '' && !isNaN(Number(value)));
-        if (!ok)
-            errs.push(`input "${field.name}" expected ${field.type}, got ${actual}`);
-    }
-}
-/**
- * The closest declared field name to `key`, for the "did you mean …?" half of an
- * unknown-input error.
- *
- * Three rules, tried in order: an exact case-insensitive match (`pagesize` →
- * `pageSize`), a substring either way (`summary` → `fields.summary`), and — the
- * one added for query/path parameters — a small EDIT DISTANCE. The first two miss
- * every substitution typo: `projekt` and `project` share no containment, so the
- * suggestion was simply absent, and it is absent exactly where it is needed most.
- * Parameter names are unfamiliar (`issuetype`, `nextPage`, `expansionLevel`), so
- * the author has no memory to fall back on.
- *
- * The threshold scales with the name's length (⌈len/4⌉, at least 1, at most 3), so
- * a short name needs a near-exact miss and a long one may be off by a few — and
- * two genuinely different fields are never conflated.
- */
-function nearestField(key, names) {
-    const lk = key.toLowerCase();
-    const exact = names.find((n) => n.toLowerCase() === lk);
-    if (exact)
-        return exact;
-    const contained = names.find((n) => n.toLowerCase().includes(lk) || lk.includes(n.toLowerCase()));
-    if (contained)
-        return contained;
-    const budget = Math.min(3, Math.max(1, Math.ceil(lk.length / 4)));
-    let best;
-    let bestD = budget + 1;
-    for (const n of names) {
-        const d = editDistance(lk, n.toLowerCase());
-        if (d < bestD) {
-            bestD = d;
-            best = n;
-        }
-    }
-    return bestD <= budget ? best : undefined;
-}
-/** Levenshtein distance, two rows — enough for field-name suggestions. */
-function editDistance(a, b) {
-    if (a === b)
-        return 0;
-    if (Math.abs(a.length - b.length) > 3)
-        return 99; // cheap bail: beyond any budget
-    let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
-    for (let i = 1; i <= a.length; i++) {
-        const row = [i];
-        for (let j = 1; j <= b.length; j++) {
-            row[j] = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-        }
-        prev = row;
-    }
-    return prev[b.length];
-}
 /**
  * Emit a transform's `inputs` in the canonical shape the node's runtime reads:
  * `collection` as a BARE variable path (not `=js:`-prefixed — it is a path