@uipath/maestro-builder-sdk 6.42.0 → 6.43.0

package/dist/serialize.js

@@ -6,12 +6,11 @@
  * resolved from the connector library (entry + v1def sidecar), matching what
  * the platform emits, so the result passes `uip maestro flow validate`.
  */
-import ixpDefinition from './ixp-definition.json' with { type: 'json' };
+import ixpDefinition from './core/ixp-definition.json' with { type: 'json' };
 import { BUNDLED_DEFINITIONS, bundledVersions } from './flow-definitions.js';
 import { LOOP_DEFAULT_VERSION, bodyUsesBreak, loopHasInnerHandles, loopVersion, loopVersionRefusal } from './loop-version.js';
-import { Expr, toExpr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmentsOf } from './flow-sdk.js';
+import { Expr, toExpr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameSegmentsOf } from './flow-sdk.js';
 import { FlowAction, FlowTrigger } from './core/node-classes.js';
-import { CONTEXT_INDEX_DEFAULTS, CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, contextIndexType } from './core/context-index.js';
 import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { rawNodeInputProblem, registeredRawType } from './raw-node-advice.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
@@ -20,25 +19,23 @@ import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { stepExits } from './flow-step-exits.js';
 import { resolveVersionCarried } from './core/nodes/versioned.js';
 import { indexCarriedDefinitions } from './core/carried-definitions.js';
-import { formFieldJsonSchema, formFieldSettingsWire, wireFormFieldType } from './core/form-field-type.js';
 import { ConnectorResolveError } from './core/connector-resolve-error.js';
 import { synthesizedDefinitionRefusal } from './core/synthesized-definition.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
 import { genericEventObjectRefusal } from './core/event-checks.js';
-import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
+import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitViolation } from './core/hitl-routing.js';
 import { STICKY_NOTE_TYPE, STICKY_NOTE_TYPE_VERSION } from './core/definitionless-node-types.js';
 import { placeholderPosition } from './node-placement.js';
 import { hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
-import { buildConfiguration } from './config.js';
-import { fnv1aX4Uuid, schemaId, stableId } from './core/stable-id.js';
-import { derivedContextSource, derivedEscalationSource, derivedToolSource, } from './core/agent-resource-identity.js';
+import { buildConfiguration } from './core/connector-configuration.js';
+import { fnv1aX4Uuid, stableId } from './core/stable-id.js';
 import { readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf, jmesString, jmesStringProblem } from './core/event-filters.js';
 import { FLOW_EXPR_DIALECT } from './core/connector-checks.js';
-import { buildConnectorInputs, connectorInputErrors as coreConnectorInputErrors, multipartBodyFieldName, transportHttpMethod } from './core/connector-inputs.js';
+import { buildConnectorInputs, connectorInputErrors as coreConnectorInputErrors, transportHttpMethod } 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.
@@ -62,14 +59,14 @@ import { outputBackingGlobal, planOutputBacking } from './flow-output-backing.js
 import { mapJsCode } from './core/js-code-spans.js';
 import { contributionPort } from './core/definition-handles.js';
 import { prepareCommand } from './core/cli-spelling.js';
-import { resourceNodeSortOrder } from './core/process-resource-sort-order.js';
-import { processResourceBindings, processResourceLocation } from './core/process-resource.js';
+import { processResourceBindings } from './core/process-resource.js';
 import { types } from './core/expr.js';
 import { SUBFLOW_START_LABEL } from './core/subflow-start.js';
-import { ownEntry } from './core/own-entry.js';
 import { endContentKey } from './flow-end-content.js';
 import { terminateStepClashMessage, terminateTwiceMessage } from './flow-terminate-names.js';
 import { jsonClone } from './core/json-clone.js';
+import { subNodeId } from './core/node-id-placeholder.js';
+import { JOB_ATTACHMENT_REF, jobAttachmentDefinition } from './core/agent-sidecar.js';
 // core-definitions.json is an object keyed by "<nodeType>@<version>".
 const DEFS = BUNDLED_DEFINITIONS;
 // FIRST occurrence wins: with multiple bundled versions of one family (HITL
@@ -86,10 +83,6 @@ const NODE_TYPE = {
     formTrigger: 'core.trigger.form',
     conversationTrigger: 'core.trigger.conversation',
     voiceTrigger: 'core.trigger.voice',
-    voiceAgent: 'uipath.agent.voice',
-    conversationalAgent: 'uipath.agent.conversational',
-    createOutgoingCall: 'uipath.conversational.voice.create-outgoing-call',
-    endCall: 'uipath.conversational.voice.end-call',
     // The two other spellings of the SAME human task, both resolvable on this
     // tenant. `hitl()` emits the base type unless `variant` names one of these;
     // all three share the model (`bpmn:UserTask` / `Actions.HITL`), the single
@@ -126,1951 +119,7 @@ const SUBFLOW_OUTPUT = {
     source: '=result.response',
     var: 'output',
 };
-/** The published-agent node type family. The agent's release key is the suffix. */
-const AGENT_PREFIX = 'uipath.core.agent.';
 /** The inline (autonomous) agent's node type — fixed, not per-instance. */
-const INLINE_AGENT_TYPE = 'uipath.agent.autonomous';
-/**
- * Build the definition for one published agent — coded or low-code, which are the
- * SAME node.
- *
- * Unbundlable for rpa's, api-workflow's and agentic-process's reason: the node type
- * carries a tenant's release key and the platform synthesizes the contract from
- * whatever somebody published there. The constants below are transcribed from what
- * the platform's oracles AGREE on, and this family is the first in the wave with
- * BOTH a rich registry answer and a large deployed corpus, so the agreement is
- * checkable rather than asserted:
- *
- *  - `uip maestro flow registry get uipath.core.agent.<key>` for ALL NINE agents on
- *    the tenant (2026-07-29): `category: 'agent'`, `sortOrder: 505` (510 since flow-core's
- *    renumber: the 54 runs from 09-01 below carry 510; `resourceNodeSortOrder`, #1045),
- *    `supportsErrorHandling: true`, `version: '1.0.0'`, the `bpmn:ServiceTask` /
- *    `Orchestrator.StartAgentJob` / `v2` model, `section: 'Published'`,
- *    `resourceSubType: 'Agent'`, `orchestratorType: 'agent'`,
- *    `debug.runtime: 'bpmnEngine'`, `runtimeConstraints.exclude: ['api-function']`,
- *    and the `<bindings.name>` / `<bindings.folderPath>` context placeholders;
- *  - **61 deployed, debug-green agent instances** across 61 dated
- *    `skill-flow-{coded,lowcode}-agent` artifacts (05-18 → 07-29): `sortOrder: 505`
- *    in 61/61, the `<folderPath>.<name>` resourceKey in 58/61 (the 3 exceptions are
- *    the in-solution shape — a bare key and an EMPTY folderPath — which 404'd at
- *    job start in those runs; that is the shape of `location: 'in-solution'`,
- *    built by `processResourceLocation`, and it starts the job when the sibling is
- *    in the solution: 54 v1 `skill-flow-coded-agent` runs, 09-01 → 10-08, carry
- *    `isInSolution: true`, 45 score 1.0 and none of the other 9 fails on a
- *    job-start 404, #1012), and the descriptor
- *    ARRAY `bindings.values` in 59/61 (2 early runs used the object form);
- *  - flow-v1's own generator, which is where those come from:
- *    `node-manifest-builder.ts::createModel` hard-codes `bpmn:ServiceTask` for every
- *    published-resource node and derives `orchestratorType` as
- *    `resourceType.toLowerCase()`.
- *
- * `shared/sample-flows/agent.flow` is explicitly NOT an oracle here: dated
- * 2026-05-12, it disagrees with both of the above in five places at once
- * (`sortOrder: 530`, a bare-GUID resourceKey, an object-shaped `bindings.values`,
- * and `=result.response` / `=result.Error` output sources). PR 11's rule — date a
- * bundled sample before trusting the layer that copied it — and this is its second
- * instance on that file.
- *
- * `outputs.output.source` is `=this`, which is what the definition declares. The
- * corpus is split (`=result.response` 45, `=this` 14, both deploying green), and the
- * split has a mechanical explanation: flow-v1's `applyOrchestratorActivityOutputs`
- * APPENDS `{name:'output', source:'=this'}` when a node declares no `output`, so
- * `=this` is what the platform writes for itself. We emit that one.
- *
- * The ONLY field that differs between a coded and a low-code agent is
- * `display.icon` — which is why one factory serves both.
- */
-function agentDef(spec) {
-    // One location slot with the other process resources: the in-solution
-    // model carries `projectId`, `projectName` AND `isInSolution: true`, as
-    // flow-core's `createModel` writes for every sibling-project resource.
-    const loc = processResourceLocation(spec);
-    const { inSolution, resourceKey } = loc;
-    const properties = {};
-    for (const [k, v] of Object.entries(spec.inputs)) {
-        properties[k] = { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' };
-    }
-    return {
-        nodeType: `${AGENT_PREFIX}${spec.key}`,
-        version: '1.0.0',
-        category: 'agent',
-        runtimeConstraints: { exclude: ['api-function'] },
-        description: loc.description,
-        tags: loc.tags,
-        sortOrder: resourceNodeSortOrder('agent'),
-        supportsErrorHandling: true,
-        display: {
-            label: spec.name,
-            icon: spec.flavour === 'coded' ? 'coded-agent' : 'autonomous-agent',
-        },
-        handleConfiguration: [
-            { position: 'left', handles: [{ id: 'input', type: 'target', handleType: 'input' }] },
-            { position: 'right', handles: [{ id: 'output', type: 'source', handleType: 'output' }] },
-        ],
-        ...loc.definitionExtras,
-        model: {
-            type: 'bpmn:ServiceTask',
-            serviceType: 'Orchestrator.StartAgentJob',
-            version: 'v2',
-            ...(inSolution ? {} : { section: 'Published' }),
-            bindings: {
-                resource: 'process',
-                resourceSubType: 'Agent',
-                resourceKey,
-                orchestratorType: 'agent',
-                values: [
-                    { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: loc.folderPath },
-                ],
-            },
-            ...loc.modelExtras,
-            context: [
-                { name: 'name', type: 'string', value: '<bindings.name>' },
-                { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
-                { name: '_label', type: 'string', value: spec.name },
-            ],
-        },
-        inputDefinition: Object.keys(properties).length ? { type: 'object', properties } : {},
-        inputDefaults: inSolution
-            ? Object.fromEntries(Object.keys(properties).map((name) => [name, '']))
-            : {},
-        outputDefinition: {
-            output: {
-                type: 'object',
-                source: '=this',
-                var: 'output',
-                // The agent's output fields as the author declared them — the same shape
-                // `registry get` returns when it can reach the deployed agent (nested under
-                // `schema`, which is the spelling gen-tests reads). Without it a downstream
-                // read is unresolvable, rightly: nothing offline could tell a real field from a
-                // typo, and this is also what fixtures the node offline.
-                ...(spec.returns && Object.keys(spec.returns).length
-                    ? {
-                        schema: {
-                            type: 'object',
-                            properties: Object.fromEntries(Object.entries(spec.returns).map(([k, t]) => [k, { type: t }])),
-                        },
-                    }
-                    : {}),
-            },
-            error: {
-                type: 'object',
-                description: 'Error information if the node fails',
-                source: '=Error',
-                var: 'error',
-            },
-        },
-        debug: { runtime: 'bpmnEngine' },
-    };
-}
-/**
- * The definition for ONE Context Grounding index resource, transcribed from the
- * platform's own registry entry (`uip maestro flow registry get
- * uipath.agent.resource.context.index.<slug>.<uuid>`, read 2026-07-31 against the
- * tenant's "Billing Dispute SOP Index"), and confirmed against the `.flow` v1
- * emits for the same index.
- *
- * Per-INSTANCE, unlike `inlineAgentDef`: the index's identity is in the node type,
- * so every tenant index is its own type — the same shape as a published agent's
- * release key. What is constant is everything else, and this builds that from the
- * one thing an author supplies (name + uuid).
- *
- * Two details are load-bearing rather than decorative:
- *
- *  * `handleConfiguration` declares a single TARGET handle `input` whose
- *    `allowedSources` are the two agent types' `context` handles, with
- *    `maxConnections: 1`. That is the mirror of the agent's own
- *    `allowedTargets: [{ nodeType: 'uipath.agent.resource.context.*' }]`, and it is
- *    what makes the designer draw the join.
- *  * `model: { source: true }` and nothing else. A resource node has no
- *    `bpmn:` type, no serviceType and no bindings — it is not a step, it is an
- *    artifact hanging off one. The v1 artifact carries no `bindings[]` entry for it
- *    at all.
- */
-function contextIndexDef(spec) {
-    return {
-        nodeType: contextIndexType(spec),
-        version: '1.0.0',
-        category: 'agent',
-        tags: ['agent-context', 'index'],
-        description: `Context grounding index "${spec.name}".`,
-        sortOrder: 505,
-        display: { label: spec.name, description: `Context grounding index "${spec.name}".`, icon: 'file-text', shape: 'circle' },
-        handleConfiguration: [
-            {
-                position: 'top',
-                handles: [{
-                        id: 'input', type: 'target', handleType: 'artifact',
-                        constraints: {
-                            maxConnections: 1,
-                            allowedSources: [
-                                { nodeType: 'uipath.agent.autonomous', handleId: 'context' },
-                                { nodeType: 'uipath.agent.conversational', handleId: 'context' },
-                            ],
-                            validationMessage: "Only Agent's context handle can connect here",
-                        },
-                    }],
-            },
-        ],
-        model: { source: true },
-        // The platform's own `inputDefinition.properties`, transcribed. Carried so the
-        // node's inputs are CHECKABLE — without an input schema nothing can validate
-        // this node's inputs at all, and a misspelled `resultCount` reaches the tenant
-        // unremarked.
-        //
-        // The registry's `allOf` conditionals (which retrieval modes require a query,
-        // and which of the query object's three modes is live) are deliberately NOT
-        // copied: they are the designer FORM's logic, and the serializer already emits
-        // a well-formed `query` for the mode it sets.
-        inputDefinition: {
-            type: 'object',
-            properties: {
-                indexId: { type: 'string' },
-                indexName: { type: 'string' },
-                folderKey: { type: 'string' },
-                folderPath: { type: 'string' },
-                retrievalMode: { type: 'string' },
-                query: { type: 'object' },
-                threshold: { type: 'number', minimum: 0, maximum: 1 },
-                resultCount: { type: 'number', minimum: 1, maximum: 40 },
-                fileExtension: { type: 'string' },
-                folderPathPrefix: { type: 'object' },
-                citations: { type: 'string' },
-                outputColumns: { type: 'array' },
-                webSearchGrounding: { type: 'object', properties: { value: { type: 'string' } } },
-            },
-        },
-    };
-}
-/**
- * Render an index's retrieval query into the platform's MODE-TAGGED object.
- *
- * The index definition's own schema (`inputDefinition.allOf`) says `query` is a
- * `oneOf` over three shapes, each identified by `mode`: `prompt` → `promptValue`,
- * `text-builder` → `textValue`, `variable` → `argumentPath`. All four fields are
- * present in the platform's `inputDefaults`; only the one the mode names is read.
- *
- * A plain string is a `prompt` (what a designer types); anything expression-shaped
- * is `text-builder`, whose `textValue` the runtime templates — the same slot the
- * `folderPathPrefix` field uses, and the reason that field ships with
- * `mode: 'text-builder'` by default.
- */
-function renderContextQuery(query, rename) {
-    const base = { mode: 'prompt', textValue: '', promptValue: '', argumentPath: '' };
-    if (query === undefined || query === null)
-        return base;
-    const rendered = renderValue(query, rename);
-    const asText = typeof rendered === 'string' ? rendered : JSON.stringify(rendered);
-    if (typeof rendered === 'string' && rendered.startsWith('=js:')) {
-        return { ...base, mode: 'text-builder', textValue: asText };
-    }
-    return { ...base, promptValue: asText };
-}
-/**
- * The `resources/<id>/resource.json` an inline agent's context index needs.
- *
- * The node is only half of a grounded agent, the same split as the agent itself
- * (see `inlineAgentJson`). The platform resolves an agent's capabilities from
- * `<source>/resources/<resource-id>/resource.json`, and `uip agent refresh` turns
- * those into the `bindings_v2.json` entries `uip solution resources refresh`
- * syncs. Keyed by the node's `inputs.source`, which is what joins the two halves.
- *
- * On the CLI path the file is the only copy: refresh strips the node and
- * re-derives it from here, so a `.flow` with the node and no file validates clean
- * and leaves the agent ungrounded. (Studio Web is the other direction — its
- * `mapContextResource` builds this file FROM the canvas node.)
- *
- * Shape and enums are the platform's `currentResourceStorageSchema`
- * (`@uipath/agents-storage-schemas`): `description`, `folderPath`, `indexName` and
- * all six `settings` keys are required, `fileExtension` is `{value}` rather than a
- * bare string, and the retrieval mode pins which extensions it accepts — hence the
- * per-mode default here against the node's flat `'All'`. An unparseable resource
- * is worse than none: `uip agent refresh` falls back to `resources: []` and drops
- * every other binding with it.
- */
-function contextResourceJson(cx, spec) {
-    const mode = cx.retrievalMode ?? CONTEXT_INDEX_DEFAULTS.retrievalMode;
-    return {
-        $resourceType: 'context',
-        id: spec.id,
-        // Null rather than absent: optional in the schema, but every deployed
-        // resource carries it, and a designer round-trip writes it back.
-        referenceKey: null,
-        name: cx.name,
-        description: `Context grounding index "${cx.name}".`,
-        contextType: 'index',
-        // Required by the schema, and load-bearing: this file carries no `indexId`,
-        // so `indexName` + `folderPath` is the whole locator, and `createIndexBinding`
-        // leaves the folder off the binding when it is empty. `check` warns when the
-        // author omits it — an index outside the deployment folder is then unresolvable.
-        folderPath: cx.folderPath ?? '',
-        indexName: cx.name,
-        settings: {
-            retrievalMode: mode,
-            // The resource's `query` is VARIANT-tagged where the node's is MODE-tagged,
-            // and the two vocabularies do not overlap. `prompt` — what a designer types
-            // as guidance — is the model-invoked `dynamic`, and its text is the
-            // `description` the model reads when deciding what to search for.
-            // `text-builder` — an expression the runtime templates — is the pre-fetched
-            // `static`, and its text is the `value`. Confirmed behaviourally: switching
-            // the SDK's `query` from a string to an expression turned the same agent's
-            // retrieval from a tool call into a pre-fetch.
-            query: spec.query.mode === 'text-builder'
-                ? { variant: 'static', value: String(spec.query.textValue ?? '') }
-                : { variant: 'dynamic', description: String(spec.query.promptValue ?? '') },
-            // `value: ''`, as the canvas writes it (flow-workbench `mapContextQueryToWire`
-            // always sets the value), so a canvas index's resource round-trips unchanged.
-            folderPathPrefix: { variant: 'static', value: '' },
-            threshold: cx.threshold ?? CONTEXT_INDEX_DEFAULTS.threshold,
-            resultCount: cx.resultCount ?? CONTEXT_INDEX_DEFAULTS.resultCount,
-            fileExtension: { value: cx.fileExtension ?? ownEntry(CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, mode) ?? 'All' },
-            // Mode-specific keys the schema REQUIRES of those two modes and rejects
-            // nowhere else, carrying the node's own constants through the enum's
-            // spelling (the node says `enabled`; the resource says `Enabled`/`Inline`).
-            ...(mode === 'deeprag' ? { citationMode: { value: 'Inline' } } : {}),
-            ...(mode === 'batchtransform'
-                ? { webSearchGrounding: { value: 'Enabled' }, outputColumns: [] }
-                : {}),
-        },
-    };
-}
-/** A `fieldSchema` object with every declared property marked required. */
-function requireAll(schema) {
-    const names = Object.keys(schema.properties);
-    return names.length === 0 ? schema : { ...schema, required: names };
-}
-/**
- * The resource `type` each deployed-resource tool kind carries in the agent
- * project, which is NOT its node-type namespace: `maestro` mints
- * `…tool.processorchestration.*` and its resource type is `processOrchestration`.
- * Read off the platform's `currentResourceStorageSchema`; flow-workbench's
- * `CANVAS_TO_STORAGE_TOOL_TYPE` maps them the same way.
- */
-const TOOL_RESOURCE_TYPE = {
-    process: 'process', api: 'api', maestro: 'processOrchestration',
-    flow: 'flow', agent: 'agent', function: 'function',
-};
-/** The resource `type` of a connector tool's file ({@link connectorToolResourceJson}). */
-const CONNECTOR_TOOL_RESOURCE_TYPE = 'integration';
-/**
- * The resource `type` of every platform built-in tool. Shared with tools the
- * DESIGNER writes and the SDK cannot (`load-attachments`, `create-file`, …), so
- * on its own it says nothing about who owns a file: `properties.toolType` does.
- */
-const INTERNAL_TOOL_RESOURCE_TYPE = 'internal';
-/**
- * Where an agent schema property points to declare "this is a FILE":
- * `{ $ref: JOB_ATTACHMENT_REF }`, with {@link jobAttachmentDefinition} under the
- * same schema's `definitions['job-attachment']`.
- */
-const JOB_ATTACHMENT_REF = '#/definitions/job-attachment';
-/**
- * The canonical `job-attachment` definition an agent schema's file field
- * `$ref`s into — the uipath-agents skill's `agent-definition.md` § File
- * Attachments ("Schema is fixed — copy verbatim"), and the same block the
- * platform's own analyze-attachments tool contract carries.
- *
- * It tells the agent runtime that an input is an Orchestrator attachment, so a
- * file tool (Analyze Files) can resolve the attachment's `ID`.
- *
- * A function, not a shared object: each schema gets its own copy, so an edit
- * to one emitted file cannot reach another.
- *
- * (The case serializer keeps its own copy in `case/entry-points.ts`: that one
- * mirrors the platform's `entry-points.json` packager byte for byte, and its
- * `MimeType` description differs.)
- */
-function jobAttachmentDefinition() {
-    return {
-        type: 'object',
-        properties: {
-            ID: { type: 'string', description: 'Orchestrator attachment key' },
-            FullName: { type: 'string', description: 'File name' },
-            MimeType: { type: 'string', description: 'MIME type, e.g. "application/pdf", "image/png"' },
-            Metadata: {
-                type: 'object',
-                description: 'Dictionary<string, string> of metadata',
-                additionalProperties: { type: 'string' },
-            },
-        },
-        required: ['ID'],
-        'x-uipath-resource-kind': 'JobAttachment',
-    };
-}
-/** The `properties.toolType` of the built-in HTTP-request tool's file (#935). */
-const HTTP_REQUEST_TOOL_TYPE = 'http-request';
-/**
- * The `resources/<id>/resource.json` a DEPLOYED-RESOURCE tool needs — the tool
- * half of what `contextResourceJson` does for an index, and inert for the same
- * reason (see that function).
- *
- * Shape from a real agent project (`WebResearchBriefingAgent`'s `CountSources`,
- * a `kind: 'process'` tool), cross-checked against the platform schema: this
- * family carries `argumentProperties` and `referenceKey` but no `iconUrl`, and
- * `exampleCalls` is present-and-empty. `location: 'solution'` and an empty
- * `properties.folderPath` are the inline-in-flow pair Studio Web's
- * `mapToolResource` writes and uipcli's `agent validate` enforces — the folder
- * itself lives in the flow's top-level `bindings[]`, which
- * `processResourceBindings` already writes for this tool.
- *
- * Returns `undefined` for every OTHER kind. Which kinds get a file is measured,
- * because `uip agent refresh` strips each resource node and re-derives it FROM
- * the file: where the node is `source`-only the round-trip is lossless, and where
- * the node carries the configuration the strip loses it and the rebuild cannot
- * put it back, so writing the file turns a valid flow INVALID.
- *
- *  * `ixp`, `clientside` — measured to fail exactly that way (`ixp` leaves the
- *    flow failing validate; `clientside` drops the four inputs its node needs).
- *  * `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` — has its own writer, {@link builtinToolResourceJson}: its
- *    `toolType` is a fixed per-tool constant, so the file is derivable offline.
- *  * `httpRequest` — has its own writer, {@link httpRequestToolResourceJson}:
- *    the file carries the request config as static `argumentProperties` and the
- *    model-facing `inputSchema`, both derivable from the node (#935).
- *
- * Which `type`/`toolType` values compile writes — and so owns and may prune —
- * is {@link compileOwnsResource}, read off the same tables these writers use.
- */
-function toolResourceJson(tr, spec) {
-    const common = {
-        $resourceType: 'tool',
-        id: spec.id,
-        name: tr.name,
-        // The runtime hands this to the MODEL as the tool's description, so an empty
-        // one is a tool the model has to guess at from its name alone.
-        description: tr.description ?? '',
-        isEnabled: true,
-        // `required` matters here where it does not on the agent's own contract: the
-        // model reads this schema to build the call, and an argument the process needs
-        // but the schema calls optional fails at run time with nothing said at compile
-        // time. The corpus fixture lists every declared argument.
-        inputSchema: requireAll(fieldSchema(tr.inputs)),
-        outputSchema: fieldSchema(tr.returns),
-        // No policies: `inlineAgent`'s tool refs carry none, and the field is
-        // required-but-emptyable.
-        guardrail: { policies: [] },
-        settings: {},
-        argumentProperties: {},
-    };
-    const resourceType = ownEntry(TOOL_RESOURCE_TYPE, tr.kind);
-    if (resourceType !== undefined) {
-        return {
-            ...common,
-            type: resourceType,
-            location: 'solution',
-            // The deployed resource's own key: what joins this tool to the release the
-            // solution declares.
-            referenceKey: tr.key,
-            // `folderPath` is EMPTY on purpose, and the tenant folder is not lost: for
-            // an inline-in-flow agent the folder lives in the flow's own top-level
-            // `bindings[]`, which `processResourceBindings` already writes for this
-            // tool. uipcli's `agent validate` says so where it enforces the pair —
-            // *"Inline-in-flow agents store folder info in the flow's top-level
-            // bindings[] rather than in the tool resource — Studio Web emits an empty
-            // folderPath here"* — and every `inlineAgent` tool is inline by definition.
-            properties: { processName: tr.name, folderPath: '', exampleCalls: [] },
-        };
-    }
-    return undefined;
-}
-/**
- * The `properties.toolType` each platform built-in tool carries in the agent
- * project. Neither the node type nor the label: `analyzefiles` is the
- * designer's "Analyze Files" and its resource is `analyze-attachments`;
- * `summarize` is the designer's DeepRAG node (`manifest_node_deepRag_display_label:
- * "Summarize"` in the vendored workbench strings) and its resource is `deep-rag`.
- * Read off the platform's `builtInToolPropertiesSchemaV40` discriminated union
- * (vendored `flow-to-bpmn.mjs`), which also lists `load-attachments` and
- * `http-request`, and the uipath-agents skill's built-in-tools reference, which
- * owns the file's body. The runtime ignores an unknown toolType silently, so
- * this table is the whole contract — one that is wrong selects no tool at all.
- */
-const BUILTIN_TOOL_TYPE = {
-    analyzefiles: 'analyze-attachments',
-    summarize: 'deep-rag',
-    batchtransform: 'batch-transform',
-};
-/** `inline` → `Inline`: the node's enum spelling to the resource schema's. */
-const enumValue = (v) => {
-    const s = String(v ?? '');
-    return s.charAt(0).toUpperCase() + s.slice(1);
-};
-/**
- * The `resources/<id>/resource.json` of a platform BUILT-IN tool (#920) — the
- * file the runtime builds the agent's tool list from. Without it the
- * `tool.builtin.*` node is inert, the same failure #806 fixed for deployed
- * resources: the agent runs with no built-in tool and the model never learns
- * it exists.
- *
- * Derived from the node's own inputs (`tdef.inputDefaults` with the author's
- * values over them), because those are what the file must agree with:
- * `uip agent refresh --inline-in-flow` shell-ifies every resource node down to
- * `{source, detail, itemsDescription}` and Studio Web re-hydrates the rest FROM
- * this file, so a value only on the node does not survive a refresh or a
- * designer round-trip.
- *
- * Shape: the skill's per-tool walkthroughs (`analyze-attachments.md`,
- * `deeprag/impl-json.md`, `batch-transform/impl-json.md`) checked against the
- * platform's `builtInToolResourceStorageSchemaV40`. Two vocabularies differ
- * from the node's, as they do for a context index (`contextResourceJson`): the
- * resource `query` is VARIANT-tagged where the node's is MODE-tagged, and its
- * enums are capitalized (`Inline`, `Enabled`). `analyze-attachments` declares
- * the model-facing call contract (`attachments` + `analysisTask` → `analysis`);
- * `deep-rag` and `batch-transform` declare empty schemas and carry their
- * configuration in `properties.settings`.
- */
-function builtinToolResourceJson(tool, label, inputs, spec) {
-    const toolType = ownEntry(BUILTIN_TOOL_TYPE, tool);
-    if (toolType === undefined)
-        return undefined;
-    const empty = { type: 'object', properties: {} };
-    const common = {
-        $resourceType: 'tool',
-        id: spec.id,
-        // Null, not absent: what identifies a built-in as NOT an external tool.
-        referenceKey: null,
-        name: label,
-        type: INTERNAL_TOOL_RESOURCE_TYPE,
-        description: String(inputs.description ?? ''),
-        isEnabled: true,
-        settings: {},
-        guardrail: { policies: [] },
-        argumentProperties: {},
-    };
-    const query = inputs.query?.mode === 'text-builder'
-        ? { variant: 'static', value: String(inputs.query.textValue ?? '') }
-        : { variant: 'dynamic', description: String(inputs.query?.promptValue ?? '') };
-    if (toolType === 'analyze-attachments') {
-        return {
-            ...common,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    attachments: {
-                        type: 'array',
-                        items: { $ref: JOB_ATTACHMENT_REF },
-                        description: String(inputs.attachmentsDescription ?? ''),
-                    },
-                    analysisTask: { type: 'string', description: String(inputs.analysisTaskDescription ?? '') },
-                },
-                required: ['attachments', 'analysisTask'],
-                definitions: { 'job-attachment': jobAttachmentDefinition() },
-            },
-            outputSchema: {
-                type: 'object',
-                properties: {
-                    analysis: {
-                        type: 'string',
-                        description: 'Analysis result of the attachments (analysis, summary, extracted information, etc.)',
-                    },
-                },
-                required: ['analysis'],
-            },
-            properties: { toolType, exampleCalls: [] },
-        };
-    }
-    if (toolType === 'deep-rag') {
-        return {
-            ...common,
-            inputSchema: empty,
-            outputSchema: empty,
-            properties: {
-                toolType,
-                exampleCalls: [],
-                settings: {
-                    contextType: 'attachments',
-                    query,
-                    folderPathPrefix: { variant: 'static' },
-                    fileExtension: { value: String(inputs.fileExtension?.value ?? 'pdf') },
-                    citationMode: { value: enumValue(inputs.citationMode?.value ?? 'inline') },
-                },
-            },
-        };
-    }
-    return {
-        ...common,
-        inputSchema: empty,
-        outputSchema: empty,
-        properties: {
-            toolType,
-            exampleCalls: [],
-            settings: {
-                contextType: 'attachments',
-                query,
-                folderPathPrefix: { variant: 'static' },
-                outputColumns: Array.isArray(inputs.outputColumns) ? inputs.outputColumns : [],
-                webSearchGrounding: { value: enumValue(inputs.webSearchGrounding?.value ?? 'enabled') },
-            },
-        },
-    };
-}
-/**
- * The six request fields of the HTTP-request tool, in the node's (and the
- * designer's file's) order, with the JSON Schema each takes in the file's
- * model-facing `inputSchema`. `headers`/`params` are name/value rows and
- * `timeout` is a number — the same normalization the node's text-builder
- * values already carry.
- */
-const HTTP_REQUEST_FIELDS = [
-    ['url', { type: 'string' }],
-    ['method', { type: 'string' }],
-    ['headers', { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, value: { type: 'string' } } } }],
-    ['params', { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, value: { type: 'string' } } } }],
-    ['body', { type: 'string' }],
-    ['timeout', { type: 'number' }],
-];
-/**
- * The `resources/<id>/resource.json` of the built-in HTTP-request tool (#935) —
- * without it the deployed agent is never offered the tool (measured: one LLM
- * call, no tool span), and `uip agent refresh --inline-in-flow` strips the node
- * to `{source}`, so the request config is lost entirely.
- *
- * Derived from the node's own mode-tagged inputs, so the two halves cannot
- * disagree. The rules are the ones Studio Web's own file follows (measured by
- * saving the agent once in the designer; a file built by these rules is
- * JSON-equal to it, and a debug run with only this file showed the tool spans):
- *
- *  * `inputSchema` declares all six fields, each with the node's `promptValue`
- *    as its description — the text the model reads when it fills the field;
- *  * `argumentProperties` pins every field NOT in `prompt` mode as
- *    `$['<field>']: {variant: 'static', value: <textValue>}` — a fixed value the
- *    model does not get to choose. The SDK writes only `prompt` and
- *    `text-builder` fields; a `text-builder` value is the literal.
- */
-function httpRequestToolResourceJson(label, inputs, spec) {
-    const properties = {};
-    const argumentProperties = {};
-    for (const [field, schema] of HTTP_REQUEST_FIELDS) {
-        const row = (inputs[field] ?? {});
-        properties[field] = { ...schema, description: String(row.promptValue ?? '') };
-        if (row.mode !== undefined && row.mode !== 'prompt') {
-            argumentProperties[`$['${field}']`] = { variant: 'static', value: row.textValue, isSensitive: false };
-        }
-    }
-    return {
-        $resourceType: 'tool',
-        id: spec.id,
-        canvasNodeId: spec.canvasNodeId,
-        name: label,
-        type: INTERNAL_TOOL_RESOURCE_TYPE,
-        description: String(inputs.description ?? ''),
-        isEnabled: true,
-        inputSchema: { type: 'object', properties, required: ['url'] },
-        outputSchema: { type: 'object', properties: {} },
-        settings: {},
-        guardrail: { policies: [] },
-        argumentProperties,
-        properties: { toolType: HTTP_REQUEST_TOOL_TYPE },
-    };
-}
-/**
- * Every tool resource identity `compile` writes, read off the tables its
- * writers use — so a tool kind cannot be written without being owned, or owned
- * without being written (#935: the #920 built-in files were written as
- * `internal` and never pruned, because ownership was a hand-kept list in
- * `compile-cli.ts` that did not have them).
- *
- *  * `types` — the resource `type`s compile owns OUTRIGHT: every deployed-resource
- *    kind's, and `integration` (connector tools, since #867).
- *  * `internalToolTypes` — `internal` is shared with designer-only built-ins
- *    (`load-attachments`, `create-file`, `jev-classifier`), so for it ownership
- *    is the `properties.toolType`, and only the ones compile writes.
- */
-export const COMPILE_WRITTEN_TOOL_RESOURCES = {
-    types: new Set([...Object.values(TOOL_RESOURCE_TYPE), CONNECTOR_TOOL_RESOURCE_TYPE]),
-    internalToolTypes: new Set([...Object.values(BUILTIN_TOOL_TYPE), HTTP_REQUEST_TOOL_TYPE]),
-};
-/**
- * Does `compile` own this `resources/<id>/resource.json` — would a compile have
- * written it, so one this compile did not write is stale rather than someone
- * else's? Everything it says no to belongs to the designer or to `uip agent
- * refresh` (escalation, mcp, designer-only built-ins, the kinds the SDK cannot
- * derive), and is never deleted.
- */
-export function compileOwnsResource(body) {
-    const kind = body?.$resourceType;
-    if (kind === 'context')
-        return true;
-    if (kind !== 'tool')
-        return false;
-    const type = String(body?.type);
-    if (type === INTERNAL_TOOL_RESOURCE_TYPE) {
-        const toolType = body?.properties?.toolType;
-        return COMPILE_WRITTEN_TOOL_RESOURCES.internalToolTypes.has(String(toolType));
-    }
-    return COMPILE_WRITTEN_TOOL_RESOURCES.types.has(type);
-}
-/**
- * The .NET type an Action Center app argument of each field type carries. Studio
- * Web serializes the task payload through `inputSchemaDotnetTypeMapping`, which
- * the platform schema REQUIRES on an `actionCenter` channel; it reads the raw
- * type off the app's action schema, which the SDK does not fetch, so this is
- * the inverse of flow-workbench's `dotNetTypeToJsonSchema` for the scalars and
- * `System.Object` for the two composite types it has no single answer for.
- */
-const DOTNET_TYPE = {
-    string: 'System.String', number: 'System.Double', integer: 'System.Int32',
-    boolean: 'System.Boolean', object: 'System.Object', array: 'System.Object',
-};
-/**
- * The folder an app escalation names: the author's `folderPath`, or
- * `solution_folder` when they gave none — an app that ships in this solution.
- *
- * `solution_folder` is the platform's own spelling for that case: it is the
- * `Folder` that `uip solution resources list` reports for a solution-internal
- * app, and what the agents skill tells authors to copy into
- * `channels[].properties.folderName`. The SDK used to write `""`, which no
- * product writer produces (flow-builder-sdk#967). Measured, the two are the
- * same everywhere it counts: the agent tool's binding generator drops both
- * from the App binding (`resolveFolderPathBindingValue`), `uip agent refresh`
- * plus `uip solution resources refresh` derive byte-identical files from
- * either, and a live debug resolves the app in the debug folder for both. So
- * this changes the vocabulary, not the behaviour.
- */
-function escalationAppFolder(app) {
-    return app.folderPath ? app.folderPath : 'solution_folder';
-}
-/**
- * The `resources/<id>/resource.json` an inline agent's ESCALATION needs — the
- * escalation half of what `toolResourceJson` does for a tool, and inert without
- * it for the same reason (#921). Measured 2026-10-05 on alpha with `uip maestro
- * flow debug`: the same agent, told to escalate every claim, answered *"could
- * not escalate: no ExpenseEscalation tool available"* with the node alone, and
- * created the Action Center task with this file beside it.
- *
- * Shape: the uipath-agents skill's agent-level escalation resource (it owns the
- * body), checked field by field against the platform's
- * `currentResourceStorageSchema` — which REQUIRES `description` (top level and
- * channel), `isAgentMemoryEnabled`, `governanceProperties`, `properties`,
- * `inputSchemaDotnetTypeMapping` and `channels[].properties.appVersion`.
- *
- * Unlike a tool, an escalation node CARRIES its configuration, and `uip agent
- * refresh --inline-in-flow` strips it to `source` either way. Writing the file
- * does not change that; it is what makes refresh keep the escalation at all
- * (`Resources: 1` and the App binding in `bindings_v2.json`, against
- * `Resources: 0` without it). The compiled `.flow` keeps the node's full inputs,
- * so `flow validate` is unaffected.
- */
-function escalationResourceJson(esc, spec) {
-    const outcomeMapping = esc.outcomes && esc.outcomes.length
-        ? Object.fromEntries(esc.outcomes.map((o) => [o, 'continue']))
-        : {};
-    const common = {
-        id: spec.channelId,
-        name: 'Channel',
-        description: esc.description ?? '',
-        outcomeMapping,
-        recipients: (esc.recipients ?? []).map((v) => ({ type: 3, value: v })),
-        taskTitle: esc.taskTitle ?? '',
-        taskTitleV2: {
-            type: 'textBuilder',
-            tokens: esc.taskTitle ? [{ type: 'simpleText', rawString: esc.taskTitle }] : [],
-        },
-        labels: esc.labels ?? [],
-        argumentProperties: {},
-    };
-    let channel;
-    if (spec.quickFormSchema !== undefined) {
-        // The INLINE form: the node's own `schema` (fields + outcomes) is the
-        // channel's, and its contract is read off the field directions — what the
-        // reviewer is shown (`input`/`inOut`) and what comes back (`output`/`inOut`).
-        const fields = esc.fields ?? [];
-        const props = (dirs) => Object.fromEntries(fields
-            .filter((f) => dirs.includes(f.direction))
-            .map((f) => [f.id, formFieldJsonSchema(f.type) ?? { type: 'string' }]));
-        channel = {
-            ...common,
-            type: 'actionCenterQuickForm',
-            inputSchema: { type: 'object', properties: props(['input', 'inOut']) },
-            outputSchema: { type: 'object', properties: props(['output', 'inOut']) },
-            properties: {
-                schema: spec.quickFormSchema,
-                isActionableMessageEnabled: false,
-                actionableMessageMetaData: null,
-            },
-        };
-    }
-    else {
-        const app = esc.app;
-        const mapping = (fields) => Object.fromEntries(Object.entries(fields ?? {}).map(([k, t]) => [k, ownEntry(DOTNET_TYPE, t) ?? 'System.Object']));
-        channel = {
-            ...common,
-            type: 'actionCenter',
-            inputSchema: fieldSchema(app.inputs),
-            outputSchema: fieldSchema(app.outputs),
-            inputSchemaDotnetTypeMapping: mapping(app.inputs),
-            outputSchemaDotnetTypeMapping: mapping(app.outputs),
-            properties: {
-                // The app's key and name are what `uip agent refresh` turns into the
-                // App binding (`name` + `folderPath`) that `uip solution resources
-                // refresh` imports; `folderName` is the app's Orchestrator folder.
-                resourceKey: app.key,
-                appName: app.name,
-                folderName: escalationAppFolder(app),
-                // The app's deploy version (its action schema's `version`). The SDK does
-                // not read the action schema, so this is the platform's own default — the
-                // storage migration that introduced the field writes `1` when absent.
-                appVersion: app.version ?? 1,
-                isActionableMessageEnabled: false,
-                actionableMessageMetaData: null,
-            },
-        };
-    }
-    return {
-        $resourceType: 'escalation',
-        id: spec.id,
-        name: esc.name,
-        description: esc.description ?? '',
-        escalationType: 0,
-        isAgentMemoryEnabled: false,
-        properties: {},
-        governanceProperties: { isEscalatedAtRuntime: false },
-        isEnabled: true,
-        channels: [channel],
-    };
-}
-/**
- * The one TARGET handle every tool resource declares: `input`, artifact-typed,
- * fed by the two agent types' `tool` handles. Transcribed from `registry get`
- * (identical across `tool.builtin.*`, `tool.connector.*` and every
- * per-instance kind, 2026-07-31) — the mirror of the agent's own
- * `allowedTargets: [{ nodeType: 'uipath.agent.resource.tool.*' }]`.
- */
-function toolInputHandle() {
-    return {
-        position: 'top',
-        handles: [{
-                id: 'input', type: 'target', handleType: 'artifact', isDefaultForType: true,
-                constraints: {
-                    maxConnections: 1,
-                    allowedSources: [
-                        { nodeType: 'uipath.agent.autonomous', handleId: 'tool' },
-                        { nodeType: 'uipath.agent.conversational', handleId: 'tool' },
-                    ],
-                    validationMessage: "Only Agent's tool handle can connect here",
-                },
-            }],
-    };
-}
-/** A `{ name: type }` field map as the JSON-schema object the platform stores. */
-function fieldSchema(fields) {
-    return {
-        type: 'object',
-        properties: Object.fromEntries(Object.entries(fields ?? {}).map(([k, t]) => [k, { type: t }])),
-    };
-}
-/**
- * The definitions for the three platform BUILT-IN tools, transcribed from
- * `uip maestro flow registry get uipath.agent.resource.tool.builtin.<name>`
- * (2026-07-31, version 1.1 all three). These are fixed types — no tenant
- * resource behind them — so unlike every other tool kind the def CAN be
- * bundled.
- *
- * One wrinkle carried faithfully rather than smoothed over: the three defs
- * disagree about where the node's `source` identity lives. `analyzefiles`
- * declares `model.source: true` (the resource-family convention);
- * `summarize`/`batchtransform` have NO model and declare `source` as an
- * ordinary input instead. Both spellings satisfy the platform's stable-UUID
- * requirement, so each def ships the registry's own shape.
- */
-const BUILTIN_TOOL_DEFS = {
-    analyzefiles: {
-        nodeType: 'uipath.agent.resource.tool.builtin.analyzefiles',
-        version: '1.1',
-        category: 'agent.tool.builtin',
-        tags: ['agent-tool', 'builtin', 'analyze', 'files', 'attachments'],
-        description: 'Extract and analyze content from files',
-        sortOrder: 48,
-        display: {
-            label: 'Analyze Files',
-            description: 'Analyze one or more files with an LLM to extract, synthesize, or answer queries about their content.',
-            icon: 'paperclip', shape: 'circle',
-        },
-        handleConfiguration: [toolInputHandle()],
-        model: { source: true },
-        inputDefinition: {
-            type: 'object',
-            properties: {
-                description: { type: 'string' },
-                attachmentsDescription: { type: 'string' },
-                itemsDescription: {
-                    type: 'array',
-                    items: { type: 'object', properties: { label: { type: 'string' }, value: { type: 'string' } } },
-                },
-                analysisTaskDescription: { type: 'string' },
-                exampleCalls: { type: 'array' },
-            },
-        },
-        inputDefaults: {
-            description: 'Analyze one or more files with an LLM to extract, synthesize, or answer queries about their content.',
-            attachmentsDescription: 'Array of files, documents, images, or other attachments to process',
-            itemsDescription: [],
-            analysisTaskDescription: "The task, question, or instruction for processing the files (e.g., 'summarize this document', 'extract key points', 'what is in this image')",
-            exampleCalls: [],
-        },
-    },
-    summarize: {
-        nodeType: 'uipath.agent.resource.tool.builtin.summarize',
-        version: '1.1',
-        category: 'agent.tool.builtin',
-        tags: ['agent-tool', 'builtin', 'summarize', 'document', 'synthesis', 'citations'],
-        description: 'Synthesize across documents with citations',
-        sortOrder: 48,
-        display: {
-            label: 'Summarize',
-            description: 'Get comprehensive synthesis across up to 1,000 pages with citations.',
-            icon: 'database', shape: 'circle',
-        },
-        handleConfiguration: [toolInputHandle()],
-        inputDefinition: {
-            type: 'object',
-            properties: {
-                description: { type: 'string' },
-                source: { type: 'string' },
-                query: { type: 'object' },
-                fileExtension: { type: 'object', properties: { value: { type: 'string' } } },
-                citationMode: { type: 'object', properties: { value: { type: 'string' } } },
-            },
-        },
-        inputDefaults: {
-            description: 'Get comprehensive synthesis across up to 1,000 pages with citations.',
-            source: '',
-            query: { mode: 'prompt', textValue: '', promptValue: '', argumentPath: '' },
-            fileExtension: { value: 'pdf' },
-            citationMode: { value: 'inline' },
-        },
-    },
-    batchtransform: {
-        nodeType: 'uipath.agent.resource.tool.builtin.batchtransform',
-        version: '1.1',
-        category: 'agent.tool.builtin',
-        tags: ['agent-tool', 'builtin', 'batch-transform', 'csv', 'transform'],
-        description: 'Process and transform CSV files',
-        sortOrder: 48,
-        display: {
-            label: 'Batch Transform',
-            description: 'Process and transform CSV files.',
-            icon: 'table', shape: 'circle',
-        },
-        handleConfiguration: [toolInputHandle()],
-        inputDefinition: {
-            type: 'object',
-            properties: {
-                description: { type: 'string' },
-                source: { type: 'string' },
-                query: { type: 'object' },
-                outputColumns: { type: 'array' },
-                webSearchGrounding: { type: 'object', properties: { value: { type: 'string' } } },
-            },
-        },
-        inputDefaults: {
-            description: 'Process and transform CSV files.',
-            source: '',
-            query: { mode: 'prompt', textValue: '', promptValue: '', argumentPath: '' },
-            outputColumns: [],
-            webSearchGrounding: { value: 'enabled' },
-        },
-    },
-};
-/**
- * The definition for one CONNECTOR-operation tool, derived from the same
- * curated-library entry `connector(…)` resolves — measured equivalence, not
- * hope: the library's `.v1def.json` `model` (bindings + the
- * connectorKey/objectName/method context) is byte-identical to what
- * `registry get uipath.agent.resource.tool.connector.<key>.<op>` returns for
- * the same operation, minus `source: true` (checked 2026-07-31 against
- * `uipath-uipath-airdk/web-search`). What the tool era changes is the frame:
- * the node type moves one namespace over, the category gains the
- * `agent.tool.` prefix over the v1def's own (which carries the connector's
- * numeric id — `connector.196640` → `agent.tool.connector.196640`), the
- * handle becomes the tool artifact handle, and `sortOrder` is the registry's
- * 565.
- */
-function connectorToolDef(rc) {
-    const v1 = rc.v1def ?? {};
-    const suffix = String(rc.nodeType).replace(/^uipath\.connector\./, '');
-    return {
-        nodeType: `uipath.agent.resource.tool.connector.${suffix}`,
-        version: v1.version ?? '1.0.0',
-        category: `agent.tool.${v1.category ?? 'connector'}`,
-        tags: ['agent-tool', 'connector', 'activity'],
-        sortOrder: 565,
-        display: { ...jsonClone(v1.display ?? {}), shape: 'circle' },
-        handleConfiguration: [toolInputHandle()],
-        model: { ...jsonClone(v1.model ?? {}), source: true },
-        inputDefinition: { type: 'object', properties: {} },
-        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>"}}`, byte for byte
- * what the product writes — `uip maestro flow node configure` (UiPath/cli
- * `connector-service.ts`, `` `{{prompt: "${f.description || f.displayName || f.name}"}}` ``)
- * and the designer's `PROMPT_WRAPPER` (@uipath/maestro-sdk) both splice the text RAW.
- * The chip format has no escape: the product's reader (`PROMPT_UNWRAPPER`) slices
- * off the fixed `{{prompt:` / `}}` frame and strips one pair of outer quotes, so
- * any text — `"`, `\`, a newline, a `}}` — round-trips. Escaping it here made the
- * model read literal backslashes. FB011 registers this as the one raw chip splice.
- */
-function promptChip(f) {
-    const text = f.description || f.displayName || f.name;
-    return `{{prompt: "${text}"}}`;
-}
-const isPromptChip = (v) => typeof v === 'string' && v.startsWith('{{prompt');
-/** The text inside `{{prompt: "…"}}`, read the way the product reads it (maestro-sdk PROMPT_UNWRAPPER); `''` when `value` is not a chip. */
-function chipText(value) {
-    if (!(value.startsWith('{{prompt:') && value.endsWith('}}')))
-        return '';
-    const inner = value.slice(9, -2).trim();
-    const quoted = (inner.startsWith('"') && inner.endsWith('"')) || (inner.startsWith("'") && inner.endsWith("'"));
-    return quoted ? inner.slice(1, -1) : inner;
-}
-/** 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: CONNECTOR_TOOL_RESOURCE_TYPE,
-        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
- * of each (2026-07-31): the five agree on the whole frame (`bpmn:ServiceTask`,
- * `version: 'v2'`, `section: 'Published'`, the `<bindings.name>` /
- * `<bindings.folderPath>` context, `source: true`, version `1.0.0`, the tool
- * artifact handle, `tags: ['agent-tool']`) and differ in exactly these rows.
- */
-const PROCESS_TOOL_META = {
-    process: { ns: 'process', serviceType: 'Orchestrator.StartJob', subType: 'Process', orchestratorType: 'process', category: 'agent.tool.rpa', icon: 'rpa', sortOrder: 550 },
-    api: { ns: 'api', serviceType: 'Orchestrator.ExecuteApiWorkflowAsync', subType: 'Api', orchestratorType: 'api', category: 'agent.tool.api', icon: 'api', sortOrder: 555 },
-    maestro: { ns: 'processorchestration', serviceType: 'Orchestrator.StartAgenticProcess', subType: 'ProcessOrchestration', orchestratorType: 'processorchestration', category: 'agent.tool.agentic-process', icon: 'agentic-process', sortOrder: 558 },
-    flow: { ns: 'flow', serviceType: 'Orchestrator.StartFlowProcess', subType: 'Flow', orchestratorType: 'flow', category: 'agent.tool.flow', icon: 'flow-project', sortOrder: 559 },
-    agent: { ns: 'agent', serviceType: 'Orchestrator.StartAgentJob', subType: 'Agent', orchestratorType: 'agent', category: 'agent.tool.agent', icon: 'autonomous-agent', sortOrder: 560 },
-    // A published FUNCTION as an agent tool (Phase 5): same shape as its
-    // siblings, with the function family's service type and binding subtype
-    // (see `publishedFunctionDef`, transcribed from the platform's manifest).
-    function: { ns: 'function', serviceType: 'Orchestrator.ExecuteFunctionAsync', subType: 'Function', orchestratorType: 'function', category: 'agent.tool.function', icon: 'function', sortOrder: 557 },
-};
-/**
- * The definition for one per-instance tool resource. Like `rpaWorkflowDef`
- * and its siblings — whose model half this shares verb for verb — the def
- * cannot be bundled: the node type carries the deployed resource's own key,
- * and the contract (`inputSchema`/`outputSchema` in `inputDefaults`, which is
- * where the registry's tenant-synthesized copy puts it) comes from the author
- * because offline nothing else can know it.
- */
-function processToolDef(kind, spec) {
-    const meta = PROCESS_TOOL_META[kind];
-    const inputProps = Object.keys(spec.inputs ?? {});
-    return {
-        nodeType: `uipath.agent.resource.tool.${meta.ns}.${spec.key}`,
-        version: '1.0.0',
-        category: meta.category,
-        tags: ['agent-tool'],
-        sortOrder: meta.sortOrder,
-        display: { label: spec.name, icon: meta.icon, shape: 'circle' },
-        handleConfiguration: [toolInputHandle()],
-        model: {
-            type: 'bpmn:ServiceTask',
-            serviceType: meta.serviceType,
-            version: 'v2',
-            section: 'Published',
-            bindings: {
-                resource: 'process',
-                resourceSubType: meta.subType,
-                resourceKey: `${spec.folderPath}.${spec.name}`,
-                orchestratorType: meta.orchestratorType,
-                values: [
-                    { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: spec.folderPath },
-                ],
-            },
-            context: [
-                { name: 'name', type: 'string', value: '<bindings.name>' },
-                { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
-                { name: '_label', type: 'string', value: spec.name },
-            ],
-            source: true,
-        },
-        // The registry's per-tenant copy declares the resource's arguments here
-        // when it can read the deployed resource; offline the author's declaration
-        // is the only source (`{}` when none — the registry's own empty shape).
-        inputDefinition: inputProps.length ? fieldSchema(spec.inputs) : {},
-        inputDefaults: {
-            ...Object.fromEntries(inputProps.map((k) => [k, null])),
-            inputSchema: fieldSchema(spec.inputs),
-            outputSchema: fieldSchema(spec.returns),
-        },
-    };
-}
-/**
- * The definition for one published IxP project AS A TOOL.
- *
- * The same registry family as `ixpExtractDef`'s one namespace over, and the
- * comparison that prices it: this def has **no `model` key at all** — which is
- * not special, it is the shape `tool.builtin.summarize` and
- * `tool.builtin.batchtransform` already carry. So an IxP tool needs no bindings
- * and no resource identity beyond the node type; the agent's own resource list
- * is what points at it. (G16 deferred this family as "`model: null`" — measured
- * again on 2026-07-31 with a fresh registry cache, the key is absent, and the
- * only genuinely new thing is the 6-field `inputDefaults` below.)
- *
- * Transcribed from `registry get uipath.agent.resource.tool.ixp.<slug>.<projectId>`
- * (2026-07-31, post-`pull --force`). Note the tail is the project's OWN id here,
- * where an extraction STEP's type carries the project VERSION id.
- */
-function ixpToolDef(spec) {
-    const slug = spec.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    const attachmentDescription = spec.attachment?.description ?? 'File to extract data from.';
-    return {
-        nodeType: `uipath.agent.resource.tool.ixp.${slug}.${spec.projectId}`,
-        version: '1.0.0',
-        category: 'agent.tool.ixp',
-        tags: ['agent-tool', 'ixp', 'document-understanding'],
-        description: '',
-        sortOrder: 575,
-        display: {
-            label: spec.name,
-            description: spec.description ?? '',
-            icon: 'file-text',
-            shape: 'circle',
-        },
-        handleConfiguration: [toolInputHandle()],
-        form: {
-            id: 'ixp-tool-form',
-            title: 'IXP Tool',
-            sections: [{
-                    id: 'ixp-settings',
-                    title: 'IXP Settings',
-                    collapsible: true,
-                    defaultExpanded: true,
-                    fields: [
-                        { name: 'inputs.name', type: 'text', label: 'Name' },
-                        { name: 'inputs.description', type: 'textarea', label: 'Description', placeholder: 'Enter tool description' },
-                        {
-                            name: 'inputs.versionTag', type: 'select', label: 'Model',
-                            placeholder: 'Select a version tag',
-                            dataSource: {
-                                type: 'fetch',
-                                url: `uipath://ixp/projects/${spec.projectId}/tags`,
-                                method: 'GET',
-                                transform: 'data.map(tag => ({ label: tag.name, value: tag.name }))',
-                            },
-                        },
-                        {
-                            name: 'inputs.attachmentConfig', type: 'custom', component: 'ixp-attachment-editor',
-                            label: '', componentProps: { defaultDescription: attachmentDescription },
-                        },
-                    ],
-                }],
-        },
-        // The tool namespace's OWN `inputDefinition` — the same 11-property
-        // catalogue, but with `required: ["fileRef"]` and no `minLength`s, because a
-        // tool has no model or folder to resolve at design time (measured: the
-        // extractor's and the tool's copies are NOT equal, even post-pull) — plus
-        // ONE deliberate widening, three keys.
-        //
-        // The registry's copy declares neither `name` nor `description`, and its own
-        // `form` binds `inputs.name` and `inputs.description` as the tool's first two
-        // fields, so a node that omits them is a tool with no name. `source` is the
-        // third: the platform's validator requires a stable uuid there on every
-        // agent-resource node (MST-9265), and its own model-less builtin tool defs
-        // declare it as an input for exactly that reason. Widening is lesson 42's
-        // other branch, taken here because — unlike the extractor's `description` —
-        // these three are load-bearing rather than inert.
-        inputDefinition: {
-            ...jsonClone(IXP_DEF.toolInputDefinition),
-            properties: {
-                ...jsonClone(IXP_DEF.toolInputDefinition.properties),
-                source: { type: 'string' },
-                name: { type: 'string' },
-                description: { type: 'string' },
-            },
-        },
-        inputDefaults: {
-            name: spec.name,
-            description: spec.description ?? '',
-            projectName: spec.name,
-            projectId: spec.projectId,
-            versionTag: spec.versionTag ?? '',
-            attachmentConfig: {
-                mode: spec.attachment?.mode ?? 'prompt',
-                description: attachmentDescription,
-                argumentPath: spec.attachment?.argumentPath ?? '',
-            },
-        },
-    };
-}
-/**
- * The definition for an ESCALATION — the `coded-action-app` variant, which is
- * the one this tenant's registry serves. Transcribed from `registry get
- * uipath.agent.resource.escalation.coded-action-app` (2026-07-31, v1.1).
- *
- * Node-type note, because it is the one place this card had to choose between
- * eras: the deployed corpus (2026-05-22) carries the BARE
- * `uipath.agent.resource.escalation`, today's registry resolves only the
- * suffixed variants, and the agent definition's own handle accepts both
- * (`allowedTargets: [{escalation}, {escalation.*}]`). New emission follows
- * what the registry can still answer for.
- */
-function escalationDef() {
-    return {
-        nodeType: 'uipath.agent.resource.escalation.coded-action-app',
-        version: '1.1',
-        category: 'agent',
-        tags: ['agentic', 'ai', 'agent', 'escalation'],
-        description: 'Escalate to a human for review or action',
-        sortOrder: 5,
-        display: {
-            label: 'Action App Escalation',
-            description: 'Escalation point for human intervention',
-            icon: 'user-round', shape: 'circle',
-        },
-        handleConfiguration: [
-            {
-                position: 'bottom',
-                handles: [{
-                        id: 'input', type: 'target', handleType: 'artifact',
-                        constraints: {
-                            maxConnections: 1,
-                            allowedSources: [
-                                { nodeType: 'uipath.agent.autonomous', handleId: 'escalation' },
-                                { nodeType: 'uipath.agent.conversational', handleId: 'escalation' },
-                            ],
-                            validationMessage: "Only Agent's escalation handle can connect here",
-                        },
-                    }],
-            },
-        ],
-        model: { source: true },
-        // ONE deliberate widening over the registry's copy, documented rather than
-        // silent: the registry's inputDefinition declares only {name, description,
-        // type} while its own inputDefaults — and every deployed escalation node in
-        // the corpus — carry six more keys (app, recipients, outcomeMapping,
-        // _additionalProps, _notifications, _appInputs). A def that under-declares
-        // what the node carries makes a validator flag OUR OWN emission — it sets
-        // inputs its type does not declare (measured: v1's deployed escalation
-        // artifact draws the same six warnings). Declaring them keeps
-        // the node checkable, which is the same reason CX's context def carries a
-        // full schema (its comment: "without it a misspelled field reaches the
-        // tenant unremarked").
-        inputDefinition: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', minLength: 1 },
-                description: { type: 'string' },
-                type: { type: 'string' },
-                app: { type: ['object', 'null'] },
-                recipients: { type: 'array' },
-                outcomeMapping: { type: ['object', 'null'] },
-                _additionalProps: { type: 'object' },
-                _notifications: { type: 'boolean' },
-                _appInputs: { type: ['object', 'null'] },
-            },
-            required: ['name'],
-        },
-        inputDefaults: {
-            name: 'Escalation',
-            description: '',
-            type: 'app-task',
-            app: null,
-            recipients: [],
-            outcomeMapping: null,
-            _additionalProps: { taskTitle: '', priority: 'medium', labels: [] },
-            _notifications: false,
-            _appInputs: null,
-        },
-    };
-}
-/**
- * The definition for ONE MCP-server tool resource, mirrored from the platform's
- * own mapper (`flow-core` `transformMcpServer`, read from the workbench dist —
- * the registry serves the family per instance, tenant-side). The node type is
- * minted from the server's name and key with the mapper's own slug rule.
- */
-function mcpToolDef(spec) {
-    const slug = (v) => v.replace(/[^a-zA-Z0-9.]+/g, '-').toLowerCase();
-    return {
-        nodeType: `uipath.agent.resource.tool.mcp.${slug(spec.name)}.${slug(spec.key)}`,
-        version: '1.0.0',
-        category: 'agent.tool.mcp',
-        tags: ['agent-tool', 'mcp', 'mcp-server'],
-        description: spec.description ?? '',
-        sortOrder: 585,
-        display: { label: spec.name, description: spec.description ?? '', icon: 'mcp', shape: 'circle' },
-        handleConfiguration: [toolInputHandle()],
-        model: { source: true },
-        inputDefaults: {
-            name: spec.name,
-            description: spec.description ?? '',
-            referenceKey: spec.key,
-            folderPath: spec.folderPath ?? '',
-            folderKey: spec.folderKey ?? '',
-            mcpType: spec.mcpType ?? '',
-            serviceName: spec.serviceName ?? '',
-            // The mapper's field name for the canonical server SLUG (historical).
-            serverUrl: spec.slug ?? '',
-            selectedTools: spec.selectedTools ?? [],
-            toolCatalog: spec.selectedTools ?? [],
-            discoveryMode: { type: 'cached', refreshSchemaBeforeCall: true },
-        },
-    };
-}
-/**
- * The definition for ONE remote-A2A tool resource, mirrored from
- * `transformRemoteA2aResource` — same provenance and slug rule as the MCP def.
- */
-function a2aToolDef(spec) {
-    const slug = (v) => v.replace(/[^a-zA-Z0-9.]+/g, '-').toLowerCase();
-    return {
-        nodeType: `uipath.agent.resource.tool.a2a.${slug(spec.name)}.${slug(spec.key)}`,
-        version: '1.0.0',
-        category: 'agent.tool.remote-a2a',
-        tags: ['agent-tool', 'remote-a2a', 'a2a', 'agent'],
-        description: spec.description ?? '',
-        sortOrder: 590,
-        display: { label: spec.name, description: spec.description ?? '', icon: 'a2a', shape: 'circle' },
-        handleConfiguration: [toolInputHandle()],
-        model: { source: true },
-        inputDefaults: {
-            name: spec.name,
-            description: spec.description ?? '',
-            slug: spec.slug,
-            cachedAgentCard: spec.cachedAgentCard ?? null,
-            referenceKey: spec.key,
-            resourceType: spec.resourceType ?? null,
-            folderPath: spec.folderPath ?? '',
-            folderKey: spec.folderKey ?? '',
-            resourceFolderPath: spec.resourceFolderPath ?? '',
-        },
-        outputDefinition: {},
-    };
-}
-/**
- * The definition for ONE episodic-memory resource, mirrored from
- * `transformEpisodicMemory`. The memory's identity rides ON the
- * inputDefinition (`memoryId`/`folderKey`), verbatim — that is where the
- * platform's own mapper puts it.
- */
-function memoryResourceDef(spec) {
-    const slug = (v) => v.replace(/[^a-zA-Z0-9.]+/g, '-').toLowerCase();
-    return {
-        nodeType: `uipath.agent.resource.memory.${slug(spec.name)}.${slug(spec.id)}`,
-        version: '1.0.0',
-        category: 'agent',
-        tags: ['agent-memory', 'memory'],
-        description: spec.description ?? '',
-        sortOrder: 15,
-        display: { label: spec.name, description: spec.description ?? '', icon: 'database', shape: 'circle' },
-        handleConfiguration: [{
-                position: 'bottom',
-                handles: [{
-                        id: 'input', type: 'target', handleType: 'artifact',
-                        constraints: {
-                            maxConnections: 1,
-                            allowedSources: [
-                                { nodeType: 'uipath.agent.autonomous', handleId: 'memory' },
-                                { nodeType: 'uipath.agent.conversational', handleId: 'memory' },
-                            ],
-                            validationMessage: "Only Agent's memory handle can connect here",
-                        },
-                    }],
-            }],
-        model: { source: true },
-        inputDefinition: {
-            memoryId: spec.id,
-            folderKey: spec.folderKey ?? '',
-            type: 'object',
-            properties: {
-                name: { type: 'string' },
-                description: { type: 'string' },
-                dynamicFewShotLearning: { type: 'boolean' },
-                semanticSimilarity: { type: 'number', minimum: 0, maximum: 1 },
-                kValue: { type: 'number' },
-                searchMode: { type: 'string' },
-            },
-        },
-        inputDefaults: {
-            name: spec.name,
-            description: spec.description ?? '',
-            dynamicFewShotLearning: true,
-            semanticSimilarity: 0,
-            kValue: 3,
-            searchMode: 'hybrid',
-        },
-    };
-}
-/** Numeric dotted compare: '1.10' > '1.9'. */
-function compareVersions(a, b) {
-    const pa = a.split('.').map(Number);
-    const pb = b.split('.').map(Number);
-    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
-        if (d !== 0)
-            return d;
-    }
-    return 0;
-}
-/**
- * The inline agent's bundled versions, oldest first, and the newest of them.
- * The newest bundled pair is the default, so there is no version literal in
- * this file: when the registry serves a newer version, `check:definitions`
- * reports the missing pair, `sync:definitions` adds it, and the default follows.
- */
-const INLINE_AGENT_VERSIONS = Object.keys(DEFS)
-    .filter((k) => k.startsWith(`${INLINE_AGENT_TYPE}@`))
-    .map((k) => k.slice(INLINE_AGENT_TYPE.length + 1))
-    .sort(compareVersions);
-const INLINE_AGENT_DEFAULT_VERSION = INLINE_AGENT_VERSIONS[INLINE_AGENT_VERSIONS.length - 1];
-/** True when a definition declares the agent's `memory` artifact handle. */
-function declaresMemoryHandle(def) {
-    return (def?.handleConfiguration ?? []).some((g) => (g?.handles ?? []).some((h) => h?.id === 'memory'));
-}
-/**
- * The definition for the INLINE autonomous agent: the bundled pair for
- * `version` (the newest by default), plus an explicit overlay of the details
- * the registry payload does not carry.
- *
- * This is the one node type in the agent family that is the SAME on every
- * tenant — it carries its own configuration instead of referencing a resource —
- * so `uip maestro flow registry get uipath.agent.autonomous` is a direct oracle
- * and the bundle entry is the registry's definition as last synced
- * (`sync:definitions` writes it through unchanged; `check:definitions --deep`
- * reports content that has moved since). Versions and content both come from
- * there.
- *
- * The overlay, and nothing else:
- *
- *  * `outputDefinition.output.source` is `=result.response`. The registry's
- *    definition declares no `source`; the deployed corpus (29 `uipath.agent.autonomous` nodes, 05-18 → 07-29) has
- *    `=result.response` in 27 of 27 that declare outputs, and the engine's own
- *    inline dispatch returns `{ response: { …declared keys } }`. Without it the
- *    node's `output` is the whole result envelope rather than the declared keys.
- *    It is applied at every version; the registry payload has no `source`.
- *  * The `memory` handle is kept only when the flow attaches memory. It is
- *    LOCAL content (#431) on the bundled 1.4, absent from the registry's 1.4
- *    (`check.ts` AGENT_MEMORY_NOT_AUTHORABLE), so an agent without memory gets
- *    the registry's handle set.
- *
- * NO per-instance schema goes on the definition: `definitions[]` is keyed by
- * node TYPE, and every inline agent in a flow shares this one entry. A flow
- * with two agents (an analyst and a writer, say) therefore cannot have both
- * contracts here — whichever was emitted last would win, and every read against
- * the other resolved to the wrong shape (GA row 7's port: 25 undeclared-field
- * errors on a correct flow). The authored contract goes on the NODE
- * (`node.outputs.output.schema`, in the `inlineAgent` arm), where a reader that
- * refines per node picks it up.
- *
- * The bundled 1.2 is the pre-#956 default, kept so a flow this SDK compiled
- * before — and a decompile of one, which pins `{ version: '1.2' }` — still
- * compiles. The corpus also carries 1.1 and 1.3; `shared/sample-flows/
- * inline-agent.flow` says 1.0, which appears in none of the 29.
- */
-function inlineAgentDef(version, withMemory, resolve = (t, v) => DEFS[`${t}@${v}`]) {
-    const bundled = resolve(INLINE_AGENT_TYPE, version);
-    if (!bundled)
-        return undefined;
-    const def = jsonClone(bundled);
-    const output = def.outputDefinition?.output;
-    if (output)
-        output.source = '=result.response';
-    if (!withMemory) {
-        for (const group of def.handleConfiguration ?? []) {
-            if (Array.isArray(group?.handles))
-                group.handles = group.handles.filter((h) => h?.id !== 'memory');
-        }
-        def.handleConfiguration = (def.handleConfiguration ?? []).filter((g) => g?.handles?.length);
-    }
-    return def;
-}
-/**
- * Classify a RENDERED input value (the output of {@link renderValue}).
- *
- * A rendered value is an expression exactly when it starts with `=js:` — the
- * same test the rest of the serializer applies, so a literal string that
- * happens to begin with `=js:` is treated as one everywhere.
- */
-function classifyAgentInput(rendered) {
-    if (typeof rendered !== 'string' || !rendered.startsWith('=js:')) {
-        return { kind: 'literal', text: String(rendered) };
-    }
-    const flatName = flatNameOf(rendered);
-    return flatName === undefined
-        ? { kind: 'expression', binding: rendered }
-        : { kind: 'ref', flatName, binding: rendered };
-}
-/**
- * The platform-facing plan for one inline agent's declared inputs.
- *
- * Built once and used by all three agent-facing sites (the node's
- * `agentInputVariables`, the sidecar's `inputSchema`, and both prompts), so they
- * cannot drift apart.
- *
- * `refs` is DEDUPED BY FLAT NAME and keeps author order. Two logical names bound
- * to the same reference are one JobArgument on the platform (v1 dedupes on a
- * seen-set, `:490-522`), so emitting two descriptors would claim an argument that
- * will not exist.
- */
-function agentInputPlan(inputs, rename) {
-    const byName = new Map();
-    const refs = [];
-    const seen = new Set();
-    for (const [name, val] of Object.entries(inputs)) {
-        const b = classifyAgentInput(renderValue(val, rename));
-        byName.set(name, b);
-        if (b.kind === 'ref' && !seen.has(b.flatName)) {
-            seen.add(b.flatName);
-            refs.push({ flatName: b.flatName, binding: b.binding });
-        }
-    }
-    return { byName, refs };
-}
-/**
- * Render an agent prompt for the SIDECAR — the author's placeholders rewritten to
- * the names the runtime will actually have.
- *
- * The three cases mirror {@link AgentInputBinding}; the fourth (a placeholder
- * naming nothing `inputs` declares) is left ALONE rather than deleted, exactly as
- * the node's renderer leaves it, so it reaches the model as visible literal text
- * and `check`'s `INLINE_AGENT_UNDECLARED_PLACEHOLDER` can name it.
- *
- * `contentTokens` is NOT rewritten separately — {@link promptTokens} runs over the
- * rewritten string, so the designer's chips and the runtime's template can't
- * disagree about a name.
- */
-function renderAgentSidecarPrompt(template, plan) {
-    return template.replace(INPUT_PLACEHOLDER, (whole, name) => {
-        const b = plan.get(name);
-        if (!b)
-            return whole;
-        if (b.kind === 'literal')
-            return b.text;
-        if (b.kind === 'ref')
-            return `{{input.${b.flatName}}}`;
-        return whole;
-    });
-}
-/**
- * The `version` every `agent.json` sidecar declares — the agent tool's
- * `AGENT_SCHEMA_VERSION` (uipath-cli `packages/agent-tool/src/templates/agent-template.ts`).
- *
- * It is not a free label. The agents backend reads an on-file `outputSchema`
- * only at `version >= 1.2.0` (UiPath/Agents#5705), and since uipath-cli#3753
- * `uip agent init` writes `1.2.0` and `uip agent validate` refuses anything else
- * with `AgentValidationOutdated` ("Agent version "1.1.0" is outdated; latest is
- * "1.2.0""). The bump is a version change only: `uip agent refresh` rewrites
- * the field and nothing else. All three writers below share this one constant
- * so they cannot fall behind separately (flow-builder-sdk#962).
- */
-const AGENT_DEFINITION_VERSION = '1.2.0';
-/**
- * The `agent.json` an inline agent's `source` directory must hold.
- *
- * The node is only half of an inline agent. flow-v1's `handleInlineAgentJob` emits
- * `entryPoint: "<source>/agent.json"` into the BPMN context, and the runtime
- * resolves the agent's real configuration — model settings, the message list, the
- * input/output schemas — from that file relative to the project. A `.flow` with an
- * inline-agent node and no such file references a definition that is not there.
- *
- * Shape transcribed from deployed agents under `runs/` (e.g. the four DevCon
- * billing agents, `type: 'lowCode'`), which is also what
- * `uip agent init --inline-in-flow` scaffolds. The `version` is
- * {@link AGENT_DEFINITION_VERSION}, not the `1.1.0` those older agents carry. `contentTokens` mirrors `content` as
- * one `simpleText` run: the designer uses those tokens to render a prompt with
- * inline variable chips, and a single run is the faithful encoding of a plain
- * string.
- */
-/**
- * The `agent.json` sidecar for a text CONVERSATIONAL agent.
- *
- * The inline agent's shape minus the argument plumbing: the turn arrives as the
- * conversation transcript, so there is no `inputSchema` keyed by flat names and
- * no `outputSchema` (the definition declares
- * `uipath__agent_response_messages`). `metadata.isConversational` is what tells
- * the platform's own storage layer which kind of agent this is.
- */
-function conversationalAgentJson(spec) {
-    return {
-        version: AGENT_DEFINITION_VERSION,
-        settings: {
-            model: spec.model,
-            // Required by the platform's agent.json schema, same as the inline
-            // agent's — a debug run without both is refused before it starts.
-            maxTokens: spec.maxTokenPerResponse ?? 16384,
-            temperature: spec.temperature ?? 0,
-            // `basic-v2` is the NON-conversational inline agent's engine (the other
-            // `agent.json` writer in this file, 100 lines down), and it was copied in
-            // with the rest of that shape. Every instance of THIS node is
-            // conversational — `metadata.isConversational` below says so
-            // unconditionally — and `voiceAgentJson`, the sibling conversational
-            // family, already spells it the other way. Measured across the 2026-09-23
-            // A/B run: every product-written `agent.json` with `isConversational: true`
-            // carries `conversational-v1` (3 of 3) and every one with `false` carries
-            // `basic-v2` (6 of 6). The SDK's own voice path agreed (2 of 2); only this
-            // path disagreed, and its task graded the sidecar as not conversational.
-            engine: 'conversational-v1',
-            ...(spec.maxIterations === undefined ? {} : { maxIterations: spec.maxIterations }),
-            mode: 'standard',
-        },
-        projectId: spec.source,
-        id: spec.source,
-        name: spec.name,
-        metadata: { storageVersion: '50.0.0', isConversational: true, showProjectCreationExperience: false },
-        type: 'lowCode',
-        guardrails: spec.guardrails ?? [],
-        messages: [
-            { role: 'system', content: spec.systemPrompt, contentTokens: promptTokens(spec.systemPrompt) },
-        ],
-    };
-}
-/**
- * The `agent.json` sidecar for a VOICE agent.
- *
- * The text agent's shape with voice-specific settings. The turn arrives as
- * audio, while optional flow context is delivered through `inputSchema` and
- * `{{input.…}}` system-prompt placeholders. There is no `outputSchema` (the
- * definition declares what comes back), and `settings.voice` carries the
- * audio configuration in the storage layer's own `StoredVoiceSettings` shape
- * (`model` / `maxTokens` / `temperature` / `persona`) — with the platform's
- * catalog defaults filled in, because its own writer treats a partial voice
- * block as incomplete.
- */
-function voiceAgentJson(spec) {
-    // The platform's catalog default (`DEFAULT_CONVERSATIONAL_VOICE_SETTINGS`):
-    // the live Gemini model, its first persona, temperature 0.
-    const DEFAULT_MODEL = 'gemini-3.1-flash-live-preview';
-    const DEFAULT_MAX_TOKENS = 65536;
-    const DEFAULT_PERSONA = 'Aoede';
-    const v = spec.voice ?? {};
-    return {
-        version: AGENT_DEFINITION_VERSION,
-        settings: {
-            engine: 'conversational-v1',
-            mode: 'voice',
-            voice: {
-                model: v.model ?? DEFAULT_MODEL,
-                maxTokens: v.maxTokens ?? DEFAULT_MAX_TOKENS,
-                temperature: v.temperature ?? 0,
-                persona: v.persona ?? DEFAULT_PERSONA,
-            },
-            ...(spec.maxIterations === undefined ? {} : { maxIterations: spec.maxIterations }),
-        },
-        projectId: spec.source,
-        id: spec.source,
-        name: spec.name,
-        ...(spec.plan.refs.length === 0 ? {} : {
-            inputSchema: {
-                type: 'object',
-                properties: Object.fromEntries(spec.plan.refs.map((r) => [r.flatName, {}])),
-            },
-        }),
-        metadata: { storageVersion: '50.0.0', isConversational: true, showProjectCreationExperience: false },
-        type: 'lowCode',
-        guardrails: [],
-        messages: (() => {
-            const system = renderAgentSidecarPrompt(spec.systemPrompt, spec.plan.byName);
-            return [{ role: 'system', content: system, contentTokens: promptTokens(system) }];
-        })(),
-    };
-}
-function inlineAgentJson(spec) {
-    return {
-        version: AGENT_DEFINITION_VERSION,
-        settings: {
-            model: spec.model,
-            // `maxTokens` and `temperature` are REQUIRED by the platform's own
-            // agent.json schema, not optional as this used to treat them: a debug run of
-            // an agent without both is refused before it starts —
-            //   settings.maxTokens   → "expected number, received undefined"
-            //   settings.temperature → "expected number, received undefined"
-            // (measured on the product runtime, GA row 7's port). Every SDK-authored
-            // inline agent hit it, and no local rung could: an offline runner calls no
-            // model and never reads agent.json, so the sidecar's platform contract had
-            // never been exercised.
-            //
-            // The defaults are what `uip agent init --inline-in-flow` writes and what
-            // v1's own reference agents for this scenario carry.
-            maxTokens: spec.maxTokenPerResponse ?? 16384,
-            temperature: spec.temperature ?? 0,
-            engine: 'basic-v2',
-            ...(spec.maxIterations === undefined ? {} : { maxIterations: spec.maxIterations }),
-            mode: spec.mode ?? 'standard',
-        },
-        // Also required, and also derived rather than authored: the agent's own
-        // directory uuid is its `projectId` and `id` (v1's scaffold writes the same
-        // value in all three places, and it is the node's `inputs.source`).
-        projectId: spec.source,
-        id: spec.source,
-        name: spec.name,
-        // Keyed by FLAT NAME, because that is what the runtime's JobArguments are
-        // keyed by (see the dialect note above). Literal- and expression-bound
-        // inputs are absent on purpose: neither has a JobArgument, so declaring one
-        // would promise an argument that never arrives.
-        //
-        // Each property is left EMPTY here and typed once the scope closes — see
-        // `typeAgentInputSchemas`, which also explains why a wrong type is fatal
-        // rather than untidy.
-        inputSchema: {
-            type: 'object',
-            properties: Object.fromEntries(spec.plan.refs.map((r) => [r.flatName, {}])),
-        },
-        outputSchema: {
-            type: 'object',
-            properties: Object.fromEntries(Object.entries(spec.returns).map(([k, t]) => [k, { type: t }])),
-            required: Object.keys(spec.returns),
-        },
-        metadata: { storageVersion: '50.0.0', isConversational: false, showProjectCreationExperience: false },
-        type: 'lowCode',
-        guardrails: spec.guardrails ?? [],
-        // `content` and `contentTokens` are the half the platform keeps EXACTLY as
-        // authored (the CLI regenerates neither), so this is where the flatName
-        // rewrite has to land. Tokens are derived from the rewritten string rather
-        // than rewritten in parallel — the designer renders from the tokens and the
-        // runtime templates the content, and the two must name the same thing.
-        messages: (() => {
-            const system = renderAgentSidecarPrompt(spec.systemPrompt, spec.plan.byName);
-            const user = renderAgentSidecarPrompt(spec.userPrompt, spec.plan.byName);
-            return [
-                { role: 'system', content: system, contentTokens: promptTokens(system) },
-                { role: 'user', content: user, contentTokens: promptTokens(user) },
-            ];
-        })(),
-    };
-}
-/** `{{input.<name>}}` — the agent-template placeholder, in both prompt directions. */
-const INPUT_PLACEHOLDER = /\{\{\s*input\.([A-Za-z_$][A-Za-z0-9_$]*)\s*\}\}/g;
-/**
- * Split an agent prompt into the `contentTokens` the designer renders it from.
- *
- * The designer shows a prompt as prose with inline variable CHIPS, and `contentTokens`
- * is that structure: alternating `simpleText` runs and `variable` entries whose
- * `rawString` is `input.<name>`. Transcribed from deployed agents under `runs/` (the
- * DevCon billing agents), where a prompt reading
- * `"…Customer Name: {{input.customerName}}\nInvoice Number: {{input.invoiceNumber}}"`
- * carries exactly that alternation.
- *
- * A prompt with no placeholders is one `simpleText` run, which is what a
- * variable-free prompt looks like there too.
- */
-function promptTokens(content) {
-    const tokens = [];
-    let last = 0;
-    for (const m of content.matchAll(INPUT_PLACEHOLDER)) {
-        const at = m.index ?? 0;
-        if (at > last)
-            tokens.push({ type: 'simpleText', rawString: content.slice(last, at) });
-        tokens.push({ type: 'variable', rawString: `input.${m[1]}` });
-        last = at + m[0].length;
-    }
-    if (last < content.length)
-        tokens.push({ type: 'simpleText', rawString: content.slice(last) });
-    return tokens.length ? tokens : [{ type: 'simpleText', rawString: content }];
-}
 /**
  * The parts every `uipath.ixp.*` definition shares, bundled verbatim from
  * `uip maestro flow registry get` (2026-07-31, after `registry pull --force`).
@@ -2437,14 +486,6 @@ function scheduleInputs(inputs, nodeId) {
         ...(isPreset ? {} : { timerValue: every }),
     };
 }
-/**
- * `Approve` → `approve`; a name that slugifies to nothing falls back to its index.
- * The same rule that names the `outcome-<id>` ports (`outcomeSlug`), so an id
- * this writes into `schema.outcomes` is always one a port can name.
- */
-function outcomeId(name, index) {
-    return outcomeSlug(name, index);
-}
 /** A required connector input left empty — the one draft code with no error class of its own. */
 export const CONNECTOR_INPUT_MISSING = 'CONNECTOR_INPUT_MISSING';
 /**
@@ -2508,10 +549,6 @@ function nodeVariables(nodes) {
     }
     return out;
 }
-/** Deep-substitute the `{nodeId}` placeholder used in definition model templates. */
-function subNodeId(obj, nodeId) {
-    return JSON.parse(JSON.stringify(obj).split('{nodeId}').join(nodeId));
-}
 const NO_RENAME = { nodeIds: new Map(), errorEnvelopes: new Map() };
 /**
  * Append the flow's `.stickyNotes()` as real `stickyNote` nodes.
@@ -2806,37 +843,29 @@ function describeDeclared(bindings) {
 /**
  * The node type a typed action compiles to, when that type's definition is
  * bundled in `core-definitions.json`. `undefined` for a family whose definition
- * is built per tenant or per call (connector, rpaWorkflow, apiWorkflow,
- * agenticProcess, publishedFunction, agent, ixpExtract) and for a spec this SDK
- * does not lower by kind.
+ * is built per tenant or per call (connector, ixpExtract) and for a spec this
+ * SDK does not lower by kind.
  *
  * A registered kind (flow-node-registry.ts) is not listed: its type is the
  * registry's.
  */
 export function bundledActionNodeType(spec) {
     switch (spec?.kind) {
-        case 'inlineAgent': return INLINE_AGENT_TYPE;
-        case 'subflow':
-        case 'createOutgoingCall':
-        case 'endCall':
-        case 'voiceAgent':
-        case 'conversationalAgent':
-            return NODE_TYPE[spec.kind];
+        case 'subflow': return NODE_TYPE.subflow;
         default: return undefined;
     }
 }
 /**
- * The definition serialize synthesizes for a family that has no bundled one:
- * a published process resource (`rpaWorkflow`, `apiWorkflow`,
- * `agenticProcess`, `publishedFunction`, `agent`) or an `ixpExtract` step.
- * Their node type carries a tenant's key, so the SDK builds the definition
- * per call, transcribed from what `registry get` returns. `undefined` for
- * every other kind (a bundled family, a connector, a container).
+ * The definition serialize synthesizes for a kind that has no bundled one and
+ * is not on the node-type registry: an `ixpExtract` step. Its node type carries
+ * a tenant's key, so the SDK builds the definition per call, transcribed from
+ * what `registry get` returns. `undefined` for every other kind (a bundled
+ * family, a connector, a container, a registered kind — the published process
+ * resources and the agent build theirs in nodes/process/flow/).
  *
  * The emit path builds its definition here, and `check` asks this same
  * definition whether the node has an error port (#1040), so the two cannot
- * disagree. For instance `publishedFunction(...)` yields
- * `uipath.core.function.<key>@1.0.0` with `supportsErrorHandling: true`.
+ * disagree.
  *
  * Throws what the family's builder throws for an unusable spec (an
  * `ixpExtract` project that is not a node type).
@@ -2844,39 +873,10 @@ export function bundledActionNodeType(spec) {
 export function perCallDefinition(spec) {
     const s = spec?.inputs ?? {};
     switch (spec?.kind) {
-        case 'agent':
-            return agentDef({
-                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
-                inputs: s.inputs ?? {}, returns: s.returns, flavour: s.flavour,
-            });
         case 'ixpExtract': return ixpExtractDef(s);
         default: return undefined;
     }
 }
-/**
- * The definition version serialize emits for a typed action step that is not
- * yet on the node-type registry: the author's `{ version }` when given,
- * otherwise the version the step's inputs select, otherwise `undefined` (the
- * pinned default). One such family picks a version itself: `inlineAgent`
- * takes the newest bundled version, not the first bundled entry.
- *
- * The emit paths read their version here, and `check` resolves the definition
- * it asks about with this same version (#1041), so the two cannot pick
- * different definitions. For instance `inlineAgent({ ... })` gives the newest
- * bundled version in both. A registered family (e.g. `dataFabricRead`, whose
- * `resultMode` selects `core.datafabric.read@1.4`) gets the same guarantee from
- * the registry's `resolveVersion`, which check and serialize both call.
- */
-export function actionVersion(spec, explicit) {
-    if (explicit !== undefined)
-        return explicit;
-    // Keyed by the node type `bundledActionNodeType` already picks, so the
-    // version rule adds no second dispatch on the step's kind.
-    const type = bundledActionNodeType(spec);
-    if (type === INLINE_AGENT_TYPE)
-        return INLINE_AGENT_DEFAULT_VERSION;
-    return undefined;
-}
 /**
  * The bundled definition of `nodeType` that `makeNode` resolves: the author's
  * exact `{ version }` when given, otherwise the pinned default (the first
@@ -4404,19 +2404,6 @@ export function serialize(built, opts = {}) {
     function successPort(type) {
         if (type === NODE_TYPE.loop)
             return 'success';
-        // The inline agent's forward handle is `success`, not `output` — its definition
-        // declares `success` (with `isDefaultForType`) + `error` on the right, and 29 of
-        // 29 deployed instances wire the outgoing edge to `success`. The PUBLISHED agent
-        // family is the opposite (`output` + `error`), which is a reminder that "the
-        // agent family" is two node shapes, not one.
-        if (type === INLINE_AGENT_TYPE)
-            return 'success';
-        // The voice family's own handles: the agent and both call actions declare
-        // `success` on the right (the two service tasks unlike their text-only
-        // conversational siblings, which declare `output`).
-        if (type === NODE_TYPE.voiceAgent || type === NODE_TYPE.createOutgoingCall
-            || type === NODE_TYPE.endCall || type === NODE_TYPE.conversationalAgent)
-            return 'success';
         // Every extractor's definition declares `success` (+ `error`, gated on
         // `errorHandlingEnabled`) on the right — so the forward edge is `success`,
         // as it is in all 151 deployed IxP instances.
@@ -4494,6 +2481,16 @@ export function serialize(built, opts = {}) {
             legacyCompletedNodes.add(id);
         else if (o.trackOutcomes && OUTCOME_HANDLE_NODE_TYPES.has(o.typeName))
             hitlNodes.set(id, node);
+        for (const a of contribution.attach ?? []) {
+            const def = a.definition;
+            const rnode = makeNode(def.nodeType, a.id, a.label, { parentId: o.parentId, def });
+            rnode.display = { ...rnode.display, shape: 'circle', ...(a.display ?? {}) };
+            // The resource model lives on the DEFINITION only.
+            delete rnode.model;
+            rnode.inputs = { ...a.inputs };
+            scope.nodes.push(rnode);
+            addEdge(scope, { node: id, port: a.port }, a.id, 'input');
+        }
         for (const t of o.tails)
             addEdge(scope, t, id);
         if (contribution.fanOut) {
@@ -4552,7 +2549,9 @@ export function serialize(built, opts = {}) {
             renameRefs: (js) => renameRefs(js, scope.rename),
             stepNodeId: (name) => scope.stepNodeId.get(name) ?? name,
             mint: (seed) => stableId(`${built.id}:${id}:${seed}`),
-            bind: (b) => { bound.push(b); },
+            // Into the flow's bindings at once as well, so `ctx.bindings` shows a pair
+            // to the step's next resource (two tools on one process share it).
+            bind: (b) => { bound.push(b); resourceBindings.set(b.id, b); },
             // At a carried version the node's own definition IS the carried one,
             // whatever version the implementation asks for (it was written for a
             // bundled one), so its defaults and outputs come from the file's entry.
@@ -4560,7 +2559,7 @@ export function serialize(built, opts = {}) {
                 ? resolved.carried
                 : bundledDefinition(typeName, v) ?? carriedFor(typeName, v)),
             bindings: resourceBindings,
-            resolveBinding: (name, attribute, at) => resolveBinding(opts, name, attribute, at),
+            resolveBinding: ((name, attribute, at, target) => resolveBinding(opts, name, attribute, at, target)),
             bindConnection: (c) => {
                 const { entries } = connectionResourceBindings({
                     def: { model: c.model },
@@ -4570,7 +2569,15 @@ export function serialize(built, opts = {}) {
                     ...(c.resourceKey !== undefined ? { resourceKey: c.resourceKey } : {}),
                 }, resourceBindings);
                 bound.push(...entries);
+                for (const b of entries)
+                    resourceBindings.set(b.id, b);
             },
+            agentSource: (carried) => agentFolder(carried, step.name),
+            sidecar: (file, explicitSource) => addSidecar(file, explicitSource),
+            typeAgentInputs: (schema, refs) => { scope.agentSchemas.push({ schema: schema, refs: [...refs] }); },
+            resourceNodeId: (explicit, seed, at) => resourceNodeId(scope, explicit, seed, at),
+            emitted: (typeName, v) => emittedDefs.get(`${typeName}@${v}`),
+            library: opts.library,
         };
         const bound = [];
         const contribution = impl.serialize(spec, ctx);
@@ -4604,7 +2611,12 @@ export function serialize(built, opts = {}) {
                 + `${JSON.stringify(nodeType)}, which is not a name under "${prefix}".`);
         }
         if (impl.definition === 'per-tenant') {
-            const port = typeof impl.errorPort === 'function' ? impl.errorPort(spec) : impl.errorPort === true;
+            // At a version the flow carries, the carried definition answers: the
+            // type's declaration speaks for the versions it registers, and an older
+            // tenant definition (an inline agent at 1.1) may have no error handle.
+            const port = resolved.carried !== undefined
+                ? definitionHasErrorPort(def ?? resolved.carried)
+                : typeof impl.errorPort === 'function' ? impl.errorPort(spec) : impl.errorPort === true;
             // The declaration answers for check, which has no definition; here the
             // definition is in hand, and the two must agree (#1011).
             if (port && def !== undefined && !definitionHasErrorPort(def)) {
@@ -4792,734 +2804,6 @@ export function serialize(built, opts = {}) {
                 addEdge(scope, t, id);
             return [{ node: id, port: successPort(rc.nodeType) }];
         }
-        if (spec.kind === 'agent') {
-            // A published agent is the FOURTH member of the process-resource family, and
-            // it goes down the same path for the same reason the other three share one:
-            // the node body, the binding pair and the model-stripping are identical, and
-            // what differs is the definition it carries. Kept as its own branch only
-            // because `inputs` is required here (the empty-input floor — see
-            // `AgentInputs.inputs`) and because the emitted binding subtype is `Agent`.
-            const s = spec.inputs;
-            const def = perCallDefinition(spec);
-            // The pair's key and folder come off the definition, as for rpa / agentic
-            // steps: one place decides the in-solution shape.
-            const pairFolder = def.model.bindings.values.find((v) => v.name === 'folderPath').default;
-            const { entries } = processResourceBindings({ name: s.name, folderPath: pairFolder, resourceSubType: 'Agent', resourceKey: def.model.bindings.resourceKey }, resourceBindings);
-            for (const b of entries)
-                resourceBindings.set(b.id, b);
-            const id = stepUid(scope, step.name);
-            const node = makeNode(def.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def });
-            // The resource model stays on the DEFINITION only, as it does for the other
-            // three published families — 58 of 61 deployed agent instances carry no
-            // node-level `model` at all.
-            delete node.model;
-            // Expression inputs stay `=js:` strings here, published or in-solution, and
-            // the format migration wraps them as `{ type: 'jsExpression', expression }`
-            // — the shape flow-core writes for an in-solution agent (52 of 54 v1
-            // expression inputs, 09-01 → 10-08; the other 2 are bare `=js:` strings,
-            // none is a `{{ }}` template). A `{ type: 'literal',
-            // expression: '{{ … }}' }` template used to be emitted instead (#1013): it
-            // ran, but it is the same envelope as a literal string, so decompile read
-            // it back as one.
-            node.inputs = renderMap(s.inputs, scope.rename);
-            scope.nodes.push(node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(def.nodeType) }];
-        }
-        if (spec.kind === 'inlineAgent') {
-            const s = spec.inputs;
-            const returns = s.returns && Object.keys(s.returns).length
-                ? s.returns
-                // The definition's own default. Deliberately kept rather than made
-                // required: it is what the platform scaffolds, so a flow that reads
-                // `content` is a real (if toy) flow. `check` says so.
-                : { content: 'string' };
-            // ONE default version for every call shape — the newest bundled pair (see
-            // `inlineAgentDef`). `mode` and `memory` used to pick the version too (1.3
-            // and 1.4), so a plain agent got a superseded 1.2 and each option moved
-            // the node to another version as a side effect (#956). Both now live in
-            // the sidecar and on edges; neither selects a definition. An explicit
-            // `{ version }` (what decompile writes back) resolves exactly.
-            const version = actionVersion(spec, step.options?.version);
-            // `definitions[]` holds one entry per type@version, so a flow where any
-            // agent attaches memory keeps the handle for all of them.
-            const withMemory = s.memory !== undefined
-                || declaresMemoryHandle(emittedDefs.get(`${INLINE_AGENT_TYPE}@${version}`));
-            const def = inlineAgentDef(version, withMemory, definitionFor);
-            if (!def) {
-                throw new Error(`"${step.name}" requests ${INLINE_AGENT_TYPE}@${version}, but this SDK resolves only `
-                    + `${INLINE_AGENT_VERSIONS.map((v) => `${INLINE_AGENT_TYPE}@${v}`).join(', ')}. Versions are exact — `
-                    + `omit { version } to use the default (${INLINE_AGENT_DEFAULT_VERSION}), request a version this SDK ships, `
-                    + `or carry that version's definition with .definitions([...]).`);
-            }
-            if (s.memory !== undefined && !declaresMemoryHandle(def)) {
-                throw new Error(`"${step.name}" attaches \`memory\`, but ${INLINE_AGENT_TYPE}@${version} declares no \`memory\` handle. `
-                    + (version === INLINE_AGENT_DEFAULT_VERSION
-                        ? `Pin a version that has it with inlineAgent({ ..., version: '<x.y>' }) `
-                            + `(bundled with memory: ${INLINE_AGENT_VERSIONS.filter((v) => declaresMemoryHandle(DEFS[`${INLINE_AGENT_TYPE}@${v}`])).join(', ') || 'none'}), or drop \`memory\`.`
-                        : `Drop { version: '${version}' } to use ${INLINE_AGENT_DEFAULT_VERSION}, or drop \`memory\`.`));
-            }
-            const id = stepUid(scope, step.name);
-            // `source` is the agent's directory name; see `agentFolder`.
-            const source = agentFolder(s.source, step.name);
-            const node = makeNode(def.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def });
-            // Unlike the published families the inline agent KEEPS no node-level model:
-            // 29 of 29 deployed instances carry none (the def's `model.source: true` is
-            // what tells the serializer the node has a `source` input).
-            delete node.model;
-            // The per-instance CONTRACT lands here, on the node, because the definition
-            // is shared by every inline agent in the flow and cannot hold it (see
-            // `inlineAgentDef`). `makeNode` copied the definition's generic `output`
-            // descriptor; this adds the declared keys to that copy, which is the shape
-            // an instance-refining reader picks up.
-            if (Object.keys(returns).length && node.outputs?.output) {
-                node.outputs.output.schema = {
-                    type: 'object',
-                    properties: Object.fromEntries(Object.entries(returns).map(([k, t]) => [k, { type: t }])),
-                };
-            }
-            const nodeInputs = s.inputs ?? {};
-            // What the PLATFORM will call each of these — computed once and shared by
-            // the descriptor array below and the sidecar. See `agentInputPlan`.
-            const plan = agentInputPlan(nodeInputs, scope.rename);
-            // A SHELL node (#927): the prompts and the model live only in the
-            // `<source>/agent.json` sidecar written below, never on the node. Studio
-            // Web decides which copy wins by `hasEmbeddedAgentContent`
-            // (@uipath/flow-schema): any `systemPrompt`/`userPrompt` string on the node
-            // makes the `.flow` authoritative and the sidecar is skipped, so a node copy
-            // shadowed the sidecar and lost the input tokens and the tool configuration
-            // on the first save. With no prompt strings the converter also keeps the
-            // `agentInputVariables` below as written (`canPruneAgentInputs` is false),
-            // and `uip maestro flow debug` reconciles them against the sidecar's
-            // `inputSchema`.
-            //
-            // The run settings (`mode`, `temperature`, `maxTokenPerResponse`,
-            // `maxIterations`, `guardrails`) live in the sidecar too. The node keeps
-            // exactly the keys Studio Web's own strip keeps (`toAgentShellInputs`,
-            // @uipath/flow-schema): anything else is discarded on hydrate, and while
-            // present it makes Studio Web "trust the .flow" when the sidecar folder is
-            // missing (`flowNodeHasRealInputs`), flushing a prompt-less agent.json.
-            // `modelMaxTokens` is written nowhere: the designer derives it from the
-            // selected model.
-            node.inputs = {
-                source,
-                // The two DESCRIPTOR ARRAYS. `agentInputVariables` entries carry the
-                // binding expression; `agentOutputVariables` entries are name + type only,
-                // and the runtime's structured final call fills exactly these keys.
-                //
-                // `id` is the FLAT NAME, not the author's — the name the runtime's
-                // JobArguments are keyed by, and the key the CLI reconciles against the
-                // sidecar's `inputSchema`. One entry per flatName, so two logical names
-                // bound to the same reference claim one argument rather than two.
-                agentInputVariables: plan.refs.map((r) => ({
-                    id: r.flatName,
-                    type: 'string',
-                    binding: r.binding,
-                })),
-                agentOutputVariables: Object.entries(returns).map(([k, t]) => ({ id: k, type: t })),
-            };
-            scope.nodes.push(node);
-            // The other half of the artifact: the agent's own configuration, which the
-            // platform resolves at `<source>/agent.json`. Collected here and written by
-            // compile-cli beside the `.flow`.
-            const agentJson = inlineAgentJson({
-                model: s.model,
-                // The AGENT's dialect: `{{input.x}}` placeholders, rewritten from the
-                // author's logical names to the FLAT NAMES the runtime's JobArguments
-                // are keyed by (board G-20). `inlineAgentJson` does the rewrite so the
-                // schema keys, the message text and the tokens all come off one plan.
-                systemPrompt: s.systemPrompt,
-                userPrompt: s.userPrompt,
-                plan,
-                returns,
-                temperature: s.temperature,
-                maxTokenPerResponse: s.maxTokenPerResponse,
-                maxIterations: s.maxIterations,
-                mode: s.mode,
-                guardrails: s.guardrails,
-                source,
-                name: step.name,
-            });
-            addSidecar({ path: `${source}/agent.json`, json: agentJson });
-            // The schema's property TYPES need this scope's finished variables, which
-            // do not exist yet — park them (the `properties` object is filled in
-            // place when the scope closes). See `typeAgentInputSchemas`.
-            scope.agentSchemas.push({ schema: agentJson.inputSchema, refs: plan.refs });
-            // GROUNDING — one resource node per context index, joined to the agent's own
-            // `context` handle. An ARTIFACT, not a step: it takes no incoming control
-            // flow, produces no output, and never reaches the End node. The edge runs OUT
-            // of the agent (source port `context`) INTO the resource's `input` port,
-            // which is the direction both definitions declare.
-            //
-            // Emitted after the agent node so the resource sits beside it in the
-            // designer's default layout rather than in front of it.
-            const contexts = s.context === undefined ? []
-                : Array.isArray(s.context) ? s.context : [s.context];
-            for (const cx of contexts) {
-                // `check`'s AGENT_CONTEXT_NO_ID, again for `--no-check`: a blank id builds
-                // the type `…context.index.<slug>.`, which no tenant serves, and nothing
-                // after this point would say so.
-                if (typeof cx?.id !== 'string' || !GUID_RE.test(cx.id)) {
-                    throw Object.assign(new Error(`inline agent "${step.name}": context index "${cx?.name ?? ''}" needs its index id (a GUID) as \`id\`; `
-                        + `got ${JSON.stringify(cx?.id)}. \`uip solution resources list --kind Index --source remote --search "<name>"\` returns it as \`Key\`.`), { code: 'AGENT_CONTEXT_NO_ID' });
-                }
-                const cdef = contextIndexDef({ name: cx.name, id: cx.id });
-                // `<step>Context`, deduped by `uid` for a second index on the same agent,
-                // unless the author placed it (`nodeId`, which decompile writes for a
-                // node the canvas named). Not slugged from the index NAME: an id is the
-                // author's handle on the node and a 40-character one helps nobody.
-                const cid = resourceNodeId(scope, cx.nodeId, `${step.name}Context`, `inline agent "${step.name}": context index "${cx.name}"`);
-                const cnode = makeNode(cdef.nodeType, cid, cx.label ?? cx.name, { parentId, def: cdef });
-                // A resource is drawn as a circle, and `makeNode` copies only the icon.
-                cnode.display = { ...cnode.display, shape: 'circle' };
-                // Same rule as the agent's: the resource `model` lives on the DEFINITION.
-                // What the NODE carries is the index's own configuration, and the platform's
-                // `inputDefaults` are the shape a designer-placed node has — so an omitted
-                // option emits the designer's value rather than nothing.
-                delete cnode.model;
-                // ONE identity, spent twice: the node's `inputs.source` and the sidecar
-                // resource's `id` are the same uuid, because that is what joins them. The
-                // platform validator says so in its own refusal text — *"the resource id
-                // from the parent inline agent's `resources[]`"*.
-                const contextResourceId = cx.source ?? derivedContextSource(built.id, step.name, cx.id);
-                const contextQuery = renderContextQuery(cx.query, scope.rename);
-                cnode.inputs = {
-                    // REQUIRED, and the platform's validator is what says so — measured
-                    // 2026-07-31, omitting it: *"Node type
-                    // uipath.agent.resource.context.index.… requires a stable UUID at
-                    // inputs.source … Set \"inputs\": { \"source\": \"<uuid>\" } on the
-                    // node"* (MST-9265). It is the resource's own identity inside the
-                    // project, so it is derived from flow + step + index rather than random,
-                    // exactly like the agent's `source`: a recompile must not be a diff.
-                    // An author's `source` (a canvas directory decompile carried) wins.
-                    source: contextResourceId,
-                    indexId: cx.id,
-                    indexName: cx.name,
-                    ...(cx.folderKey === undefined ? {} : { folderKey: cx.folderKey }),
-                    ...(cx.folderPath === undefined ? {} : { folderPath: cx.folderPath }),
-                    retrievalMode: cx.retrievalMode ?? 'semantic',
-                    // The platform's `query` is a MODE-TAGGED object, not a bare string:
-                    // `{mode, textValue, promptValue, argumentPath}`, with the mode saying
-                    // which field is live. A plain string is the `prompt` mode; a flow
-                    // expression is `text-builder`, whose `textValue` the runtime templates.
-                    query: contextQuery,
-                    threshold: cx.threshold ?? 0,
-                    resultCount: cx.resultCount ?? 3,
-                    fileExtension: cx.fileExtension ?? 'All',
-                    folderPathPrefix: { mode: 'text-builder', textValue: '', promptValue: '', argumentPath: '' },
-                    citations: 'enabled',
-                    outputColumns: [],
-                    webSearchGrounding: { value: 'enabled' },
-                };
-                scope.nodes.push(cnode);
-                addEdge(scope, { node: id, port: 'context' }, cid, 'input');
-                // The other half — without it the node is inert: see
-                // `contextResourceJson`.
-                addSidecar({
-                    path: `${source}/resources/${contextResourceId}/resource.json`,
-                    json: contextResourceJson(cx, { id: contextResourceId, query: contextQuery }),
-                }, cx.source !== undefined);
-            }
-            // TOOLS — one resource node per tool, joined to the agent's `tool` handle;
-            // the same artifact shape as context (no incoming control flow, no output,
-            // never reaches End — a graph walk drops it).
-            //
-            // Every tool node carries `inputs.source` — the platform's validator
-            // requires "a stable UUID at inputs.source … the resource id from the
-            // parent inline agent's resources[] for agent-tool resource nodes"
-            // (MST-9265's own wording) — derived, so a recompile is not a diff.
-            const toolRefs = s.tools === undefined ? []
-                : Array.isArray(s.tools) ? s.tools : [s.tools];
-            for (const tr of toolRefs) {
-                let tdef;
-                let label;
-                let extraInputs = {};
-                let connectorTool;
-                if (tr.kind === 'builtin') {
-                    const def = ownEntry(BUILTIN_TOOL_DEFS, tr.tool);
-                    tdef = def === undefined ? undefined : jsonClone(def);
-                    if (!tdef)
-                        throw new Error(`inline agent "${step.name}": unknown builtin tool "${tr.tool}" (analyzefiles | summarize | batchtransform).`);
-                    label = tdef.display.label;
-                    // The designer-placed node carries the def's `inputDefaults` with the
-                    // author's values over them — CX's context rule, kept per builtin
-                    // (each def declares different fields, so overrides apply only where
-                    // the def has the field).
-                    extraInputs = jsonClone(tdef.inputDefaults);
-                    // summarize/batchtransform declare `source` among their defaults (as
-                    // an empty string); the derived uuid below must win, not be clobbered.
-                    delete extraInputs.source;
-                    if (tr.description !== undefined)
-                        extraInputs.description = tr.description;
-                    if ('query' in extraInputs && tr.query !== undefined) {
-                        extraInputs.query = renderContextQuery(tr.query, scope.rename);
-                    }
-                    if ('fileExtension' in extraInputs && tr.fileExtension !== undefined) {
-                        extraInputs.fileExtension = { value: tr.fileExtension };
-                    }
-                    if ('citationMode' in extraInputs && tr.citationMode !== undefined) {
-                        extraInputs.citationMode = { value: tr.citationMode };
-                    }
-                }
-                else if (tr.kind === 'ixp') {
-                    tdef = ixpToolDef(tr);
-                    label = tr.name;
-                    // The node carries the def's own `inputDefaults` (name / description /
-                    // project identity / attachment config) with the derived `source` over
-                    // them — the builtin-tool rule, not the process-tool one, because this
-                    // family's configuration lives on the NODE rather than in a binding:
-                    // its def declares no `model` at all, so there is no resource identity
-                    // to bind and nothing to add to `bindings[]`.
-                    extraInputs = jsonClone(tdef.inputDefaults);
-                }
-                else if (tr.kind === 'connector') {
-                    if (!opts.library)
-                        throw new Error(`inline agent "${step.name}"'s connector tool needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
-                    const rc = opts.library.resolve(tr.connector, tr.operation, tr.version, tr.object);
-                    // An entry `prepare` synthesized from Integration Service compiles in
-                    // BPMN only — for a tool as for a step: `connectorToolDef` reads the
-                    // same definition, and a synthesized one has no form or handles.
-                    const noDefinition = synthesizedDefinitionRefusal(rc);
-                    if (noDefinition)
-                        throw noDefinition;
-                    tdef = connectorToolDef(rc);
-                    label = tr.name ?? rc.v1def?.display?.label ?? tr.operation;
-                    // 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
-                    // def's own defaults (server identity + tool selection) — the
-                    // configuration lives on the node, not in a binding.
-                    tdef = mcpToolDef(tr);
-                    label = tr.name;
-                    extraInputs = jsonClone(tdef.inputDefaults);
-                }
-                else if (tr.kind === 'a2a') {
-                    tdef = a2aToolDef(tr);
-                    label = tr.name;
-                    extraInputs = jsonClone(tdef.inputDefaults);
-                }
-                else if (tr.kind === 'clientside') {
-                    // A static bundled def: the flow declares only the CONTRACT — the
-                    // calling application owns the implementation.
-                    tdef = jsonClone(DEFS['uipath.agent.resource.tool.clientside@1.0']);
-                    label = tr.name;
-                    extraInputs = {
-                        ...jsonClone(tdef.inputDefaults),
-                        name: tr.name,
-                        ...(tr.description !== undefined ? { description: tr.description } : {}),
-                        ...(tr.inputs !== undefined ? { inputSchema: fieldSchema(tr.inputs) } : {}),
-                        ...(tr.returns !== undefined ? { outputSchema: fieldSchema(tr.returns) } : {}),
-                    };
-                }
-                else if (tr.kind === 'httpRequest') {
-                    // Each field is a mode triple: a FIXED author value rides as
-                    // text-builder (headers/params as name/value rows, timeout numeric —
-                    // the storage layer's own normalization), an omitted one keeps the
-                    // definition's prompt-mode default so the MODEL fills it at call time.
-                    tdef = jsonClone(DEFS['uipath.agent.resource.tool.builtin.httprequest@1.0']);
-                    label = tr.name ?? tdef.display.label;
-                    extraInputs = jsonClone(tdef.inputDefaults);
-                    const fix = (field, value) => {
-                        const row = extraInputs[field];
-                        extraInputs[field] = { ...row, mode: 'text-builder', textValue: value };
-                    };
-                    if (tr.url !== undefined)
-                        fix('url', tr.url);
-                    if (tr.method !== undefined)
-                        fix('method', tr.method);
-                    if (tr.headers !== undefined)
-                        fix('headers', tr.headers);
-                    if (tr.params !== undefined)
-                        fix('params', tr.params);
-                    if (tr.body !== undefined)
-                        fix('body', tr.body);
-                    if (tr.timeout !== undefined)
-                        fix('timeout', tr.timeout);
-                    // Always set, falling back to the definition's own text: the resource
-                    // file hands this to the MODEL as the tool's description, and the node
-                    // must carry the same one (#935).
-                    extraInputs.description = tr.description ?? String(tdef.description ?? '');
-                }
-                else {
-                    const meta = ownEntry(PROCESS_TOOL_META, tr.kind);
-                    if (!meta)
-                        throw new Error(`inline agent "${step.name}": unknown tool kind "${tr.kind}".`);
-                    tdef = processToolDef(tr.kind, tr);
-                    label = tr.name;
-                    // The definition's `model.context` names `<bindings.name>` /
-                    // `<bindings.folderPath>` — the same pair every published-resource
-                    // STEP references — so the entries must exist at the top level
-                    // (v1's current authoring doc says so for process tools; a def
-                    // whose bindings resolve to nothing is a dangling reference).
-                    const { entries } = processResourceBindings({ name: tr.name, folderPath: tr.folderPath, resourceSubType: meta.subType }, resourceBindings);
-                    for (const b of entries)
-                        resourceBindings.set(b.id, b);
-                    // The NODE stays minimal — `source` only. Both witnesses agree: the
-                    // deployed corpus carries `inputs: {}` on every per-instance tool, and
-                    // v1's current authoring doc says "inputs.source only, no instance
-                    // model". The contract (inputSchema/outputSchema) lives on the
-                    // DEFINITION's inputDefaults, where the registry's tenant-synthesized
-                    // copy puts it — emitting it on the node too would set inputs the
-                    // def's own schema does not declare (our own output would be flagged).
-                }
-                const tid = resourceNodeId(scope, tr.nodeId, `${step.name}Tool`, `inline agent "${step.name}": ${tr.kind} tool "${label}"`);
-                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;
-                const toolResourceId = tr.source ?? derivedToolSource(built.id, step.name, tr);
-                tnode.inputs = {
-                    source: toolResourceId,
-                    ...extraInputs,
-                };
-                scope.nodes.push(tnode);
-                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
-                // designer rather than guessed.
-                const toolResource = connectorTool
-                    ? connectorToolResourceJson(connectorTool, toolResourceId)
-                    : tr.kind === 'builtin'
-                        ? builtinToolResourceJson(tr.tool, label, tnode.inputs, { id: toolResourceId })
-                        : tr.kind === 'httpRequest'
-                            ? httpRequestToolResourceJson(label, tnode.inputs, { id: toolResourceId, canvasNodeId: tid })
-                            : toolResourceJson(tr, { id: toolResourceId });
-                if (toolResource !== undefined) {
-                    addSidecar({
-                        path: `${source}/resources/${toolResourceId}/resource.json`,
-                        json: toolResource,
-                    }, tr.source !== undefined);
-                }
-            }
-            // ESCALATION — the agent's TOP handle; an Action Center app task a human
-            // completes. The node's inputs are the platform's `inputDefaults` shape
-            // with the author's values — the exact shape the deployed corpus carries.
-            const escalations = s.escalation === undefined ? []
-                : Array.isArray(s.escalation) ? s.escalation : [s.escalation];
-            for (const esc of escalations) {
-                if (esc.variant === 'quick-form') {
-                    // The INLINE-form escalation: the same schema rows a human task's
-                    // quick form carries, on the bundled `.quick-form` definition (the
-                    // tenant registry does not serve the family).
-                    const qdef = jsonClone(DEFS['uipath.agent.resource.escalation.quick-form@1.2']);
-                    const qid = resourceNodeId(scope, esc.nodeId, `${step.name}Escalation`, `inline agent "${step.name}": escalation "${esc.name}"`);
-                    const qnode = makeNode(qdef.nodeType, qid, esc.name, { parentId, def: qdef });
-                    qnode.display = { ...qnode.display, shape: 'circle' };
-                    delete qnode.model;
-                    const rows = (esc.fields ?? []).map((f) => {
-                        const required = f.direction === 'input' ? undefined : f.required;
-                        return {
-                            id: f.id,
-                            label: f.label ?? f.id,
-                            type: wireFormFieldType(f.type),
-                            direction: f.direction,
-                            ...(typeof required === 'boolean' ? { required } : {}),
-                            // The field's settings (`controlType`, a picker's `options`,
-                            // `defaultValue`, `colSpan`, …), as the human task's rows carry
-                            // them (#1235, #1250).
-                            ...formFieldSettingsWire(f),
-                        };
-                    });
-                    const qsource = esc.source ?? derivedEscalationSource(built.id, step.name, esc.name);
-                    qnode.inputs = {
-                        source: qsource,
-                        name: esc.name,
-                        description: esc.description ?? '',
-                        type: 'quick-form',
-                        schema: {
-                            // The runtime refuses a quick form without one (`AGENT_STARTUP.
-                            // INVALID_TOOL_CONFIG`: "has a quick form schema without a
-                            // schemaId", measured 2026-10-05) — the same stable id a human
-                            // task's form carries.
-                            schemaId: schemaId(built.id, qid),
-                            fields: rows,
-                            outcomes: (esc.outcomes ?? []).map((o, i) => ({
-                                id: outcomeId(o, i), name: o, type: 'string', isPrimary: i === 0, action: 'Continue',
-                            })),
-                        },
-                        recipients: (esc.recipients ?? []).map((v) => ({ type: 3, value: v })),
-                        outcomeMapping: esc.outcomes && esc.outcomes.length
-                            ? Object.fromEntries(esc.outcomes.map((o) => [o, 'continue']))
-                            : null,
-                        _additionalProps: {
-                            taskTitle: esc.taskTitle ?? '',
-                            priority: esc.priority ?? 'medium',
-                            labels: esc.labels ?? [],
-                        },
-                        _notifications: false,
-                    };
-                    scope.nodes.push(qnode);
-                    addEdge(scope, { node: id, port: 'escalation' }, qid, 'input');
-                    // The other half — without it the escalation is inert: see
-                    // `escalationResourceJson`.
-                    addSidecar({
-                        path: `${source}/resources/${qsource}/resource.json`,
-                        json: escalationResourceJson(esc, {
-                            id: qsource,
-                            channelId: fnv1aX4Uuid(`${built.id}/${step.name}/escalation/${esc.name}/channel`),
-                            quickFormSchema: qnode.inputs.schema,
-                        }),
-                    }, esc.source !== undefined);
-                    continue;
-                }
-                const app = esc.app;
-                const edef = escalationDef();
-                const eid = resourceNodeId(scope, esc.nodeId, `${step.name}Escalation`, `inline agent "${step.name}": escalation "${esc.name}"`);
-                const enode = makeNode(edef.nodeType, eid, esc.name, { parentId, def: edef });
-                enode.display = { ...enode.display, shape: 'circle' };
-                delete enode.model;
-                const esource = esc.source ?? derivedEscalationSource(built.id, step.name, esc.name);
-                enode.inputs = {
-                    source: esource,
-                    name: esc.name,
-                    description: esc.description ?? '',
-                    type: 'app-task',
-                    app: {
-                        key: app.key,
-                        name: app.name,
-                        appName: app.name,
-                        displayName: app.name,
-                        folderPath: escalationAppFolder(app),
-                        inputSchema: fieldSchema(app.inputs),
-                        outputSchema: fieldSchema(app.outputs),
-                    },
-                    // `{type: 3, value: <email>}` is the deployed corpus's recipient
-                    // shape (type 3 = email address).
-                    recipients: (esc.recipients ?? []).map((v) => ({ type: 3, value: v })),
-                    // Every deployed outcome maps to 'continue' — the agent resumes with
-                    // the reviewer's answer whichever outcome they pick.
-                    outcomeMapping: esc.outcomes && esc.outcomes.length
-                        ? Object.fromEntries(esc.outcomes.map((o) => [o, 'continue']))
-                        : null,
-                    _additionalProps: {
-                        taskTitle: esc.taskTitle ?? '',
-                        priority: esc.priority ?? 'medium',
-                        labels: esc.labels ?? [],
-                    },
-                    _notifications: false,
-                    _appInputs: null,
-                };
-                scope.nodes.push(enode);
-                addEdge(scope, { node: id, port: 'escalation' }, eid, 'input');
-                addSidecar({
-                    path: `${source}/resources/${esource}/resource.json`,
-                    json: escalationResourceJson(esc, {
-                        id: esource,
-                        channelId: fnv1aX4Uuid(`${built.id}/${step.name}/escalation/${esc.name}/channel`),
-                    }),
-                }, esc.source !== undefined);
-            }
-            // MEMORY — one episodic-memory resource on the agent's `memory` handle
-            // (the 1.4 definition selected above). Same artifact shape as context.
-            if (s.memory !== undefined) {
-                const m = s.memory;
-                const mdef = memoryResourceDef(m);
-                const mid = uid(scope, `${step.name}Memory`);
-                const mnode = makeNode(mdef.nodeType, mid, m.name, { parentId, def: mdef });
-                mnode.display = { ...mnode.display, shape: 'circle' };
-                delete mnode.model;
-                mnode.inputs = {
-                    source: fnv1aX4Uuid(`${built.id}/${step.name}/memory/${m.id}`),
-                    name: m.name,
-                    description: m.description ?? '',
-                    dynamicFewShotLearning: m.dynamicFewShotLearning ?? true,
-                    semanticSimilarity: m.semanticSimilarity ?? 0,
-                    kValue: m.kValue ?? 3,
-                    searchMode: m.searchMode ?? 'hybrid',
-                };
-                scope.nodes.push(mnode);
-                addEdge(scope, { node: id, port: 'memory' }, mid, 'input');
-                // No `features/<id>/feature.json` until `check` stops refusing memory
-                // (AGENT_MEMORY_NOT_AUTHORABLE); its shape maps cleanly off `AgentMemoryRef`
-                // but cannot be exercised while the handle does not exist.
-            }
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(def.nodeType) }];
-        }
-        if (spec.kind === 'conversationalAgent') {
-            // The text CONVERSATIONAL agent: the inline agent's cluster shape (a
-            // minted `source` plus an `agent.json` sidecar) with the family's own
-            // turn wiring. The per-turn bindings live in `conversationalAgentSettings`
-            // — the platform's serializer reads that sub-object and turns it into the
-            // engine's `fpsProperties`, so the SDK writes the designer's shape and
-            // lets the platform do that translation.
-            const s = spec.inputs;
-            const id = stepUid(scope, step.name);
-            const source = agentFolder(s.source, step.name);
-            const node = makeNode(NODE_TYPE.conversationalAgent, id, step.name, { parentId, requestedVersion: step.options?.version });
-            delete node.model;
-            const st = s.settings ?? {};
-            // The FOUR individual fields are the runtime's source of truth — the
-            // platform's own editor says so ("they always reflect the current
-            // configuration regardless of mode; `mode` and `context` exist only to
-            // restore the editor UI"), and its validator refuses a node without
-            // `conversationId` even when a context binding is present. So `'simple'`
-            // mode DERIVES them from the context exactly as `deriveFieldsFromContext`
-            // does, appending each field's own context path (note `latestExchangeId`,
-            // which is not the field's own name).
-            const rendered = (v) => renderValue(toExpr(v), scope.rename);
-            const ctxExpr = st.context === undefined ? undefined : toExpr(st.context);
-            const derive = (contextPath) => {
-                if (ctxExpr === undefined || ctxExpr.literal)
-                    return undefined;
-                return renderValue(new Expr(`${ctxExpr.js}.${contextPath}`), scope.rename);
-            };
-            const field = (authored, contextPath) => authored !== undefined ? rendered(authored) : derive(contextPath);
-            const settings = {
-                mode: st.mode ?? 'simple',
-                ...(st.context !== undefined ? { context: rendered(st.context) } : {}),
-            };
-            for (const [key, contextPath] of [
-                ['conversationId', 'conversationId'],
-                ['exchangeId', 'latestExchangeId'],
-                ['messages', 'messages'],
-                ['userSettings', 'userSettings'],
-            ]) {
-                const v = field(st[key], contextPath);
-                if (v !== undefined)
-                    settings[key] = v;
-            }
-            // A SHELL node, like the inline agent's (#927): exactly the keys
-            // `toAgentShellInputs` keeps. The system prompt, the model and the run
-            // settings live only in the sidecar (`metadata.isConversational` there is
-            // the family flag). `endExchange` is written nowhere: the platform retired
-            // it (the node's v1.7 migration drops it, and the converter always sends
-            // `conversationalService.endExchange = ''`).
-            node.inputs = {
-                source,
-                conversationalAgentSettings: settings,
-            };
-            scope.nodes.push(node);
-            addSidecar({
-                path: `${source}/agent.json`,
-                json: conversationalAgentJson({
-                    model: s.model, systemPrompt: s.systemPrompt, temperature: s.temperature,
-                    maxTokenPerResponse: s.maxTokenPerResponse, maxIterations: s.maxIterations,
-                    guardrails: s.guardrails, source, name: step.name,
-                }),
-            });
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(NODE_TYPE.conversationalAgent) }];
-        }
-        if (spec.kind === 'createOutgoingCall' || spec.kind === 'endCall') {
-            // The two VOICE service tasks. Both keep the service model on the
-            // DEFINITION (the family convention) and write the author's fields over
-            // the definition's own empty defaults.
-            const type = spec.kind === 'createOutgoingCall' ? NODE_TYPE.createOutgoingCall : NODE_TYPE.endCall;
-            const id = stepUid(scope, step.name);
-            const node = makeNode(type, id, step.name, { parentId, requestedVersion: step.options?.version });
-            delete node.model;
-            const defaults = jsonClone(defByType.get(type)?.inputDefaults ?? {});
-            node.inputs = spec.kind === 'createOutgoingCall'
-                ? {
-                    ...defaults,
-                    from: renderValue(toExpr(spec.inputs.from), scope.rename),
-                    to: typeof spec.inputs.to === 'string'
-                        ? { type: 'literal', expression: spec.inputs.to, fieldType: 'string' }
-                        : renderValue(toExpr(spec.inputs.to), scope.rename),
-                }
-                : {
-                    ...defaults,
-                    // The whole call-context OBJECT, not a scalar — bound from a
-                    // trigger or a create-call step.
-                    callContext: renderValue(toExpr(spec.inputs.callContext), scope.rename),
-                };
-            scope.nodes.push(node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(type) }];
-        }
-        if (spec.kind === 'voiceAgent') {
-            // A VOICE agent: the inline agent's cluster shape (a `source` uuid plus an
-            // `agent.json` sidecar the platform resolves at `<source>/agent.json`),
-            // with the voice family's own inputs. There is no prompt templating and
-            // no declared `returns` — the turn comes from the live call, and the
-            // definition declares what comes back.
-            const s = spec.inputs;
-            const id = stepUid(scope, step.name);
-            const source = agentFolder(s.source, step.name);
-            const node = makeNode(NODE_TYPE.voiceAgent, id, step.name, { parentId, requestedVersion: step.options?.version });
-            // Same rule as the inline agent's: the resource model lives on the
-            // definition (its `model.source: true` is what makes `source` an input).
-            delete node.model;
-            const nodeInputs = s.inputs ?? {};
-            const plan = agentInputPlan(nodeInputs, scope.rename);
-            // A SHELL node (#927): the system prompt and the `voice` settings live only
-            // in the sidecar's `messages` and `settings.voice`. On a voice node either
-            // one makes Studio Web treat the `.flow` as authoritative and skip the
-            // sidecar (`hasEmbeddedAgentContent`). `uip maestro flow debug` builds the
-            // voice agent from the sidecar (`packageInlineAgents`).
-            // The node keeps exactly the keys `toAgentShellInputs` keeps;
-            // `maxIterations` and `metadata.isConversational` are in the sidecar.
-            node.inputs = {
-                source,
-                callContext: renderValue(toExpr(s.callContext), scope.rename),
-                ...(plan.refs.length === 0 ? {} : {
-                    agentInputVariables: plan.refs.map((r) => ({
-                        id: r.flatName,
-                        type: 'string',
-                        binding: r.binding,
-                    })),
-                }),
-            };
-            scope.nodes.push(node);
-            // The sidecar half, in the voice dialect: `settings.voice` carries the
-            // audio configuration (the storage layer's own StoredVoiceSettings
-            // shape), and the messages carry the system prompt alone.
-            addSidecar({
-                path: `${source}/agent.json`,
-                json: voiceAgentJson({
-                    systemPrompt: s.systemPrompt,
-                    plan,
-                    voice: s.voice,
-                    maxIterations: s.maxIterations,
-                    source,
-                    name: step.name,
-                }),
-            });
-            if (plan.refs.length > 0) {
-                const agentJson = sidecars[sidecars.length - 1].json;
-                scope.agentSchemas.push({ schema: agentJson.inputSchema, refs: plan.refs });
-            }
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(NODE_TYPE.voiceAgent) }];
-        }
         if (spec.kind === 'ixpExtract') {
             const s = spec.inputs;
             const def = perCallDefinition(spec); // ixpExtractDef: throws on an unparseable project