@uipath/maestro-builder-sdk 6.41.2 → 6.43.0

package/dist/nodes/agent/flow/check.js

@@ -0,0 +1,873 @@
+import { Expr } from '../../../core/expr.js';
+import { derivedResourceNodeId } from '../../../core/agent-resource-identity.js';
+import { GUID_RE } from '../../../core/binding-messages.js';
+import { prepareCommand } from '../../../core/cli-spelling.js';
+import { nearestName } from '../../../core/edit-distance.js';
+import { FLAT_SEP, flatNameOf, flatNameSegmentsOf } from '../../../core/expr.js';
+import { FORM_FIELD_TYPES, formFieldOptionsProblem, formFieldOptionsWhy, formFieldSettingProblems, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText, } from '../../../core/form-field-type.js';
+import { ownEntry } from '../../../core/own-entry.js';
+export const AGENT_DIAGNOSTICS = {
+    AGENT_CONTEXT_NO_FOLDER_PATH: { severity: 'warning', summary: 'a context index with no folderPath' },
+    AGENT_CONTEXT_NO_ID: { severity: 'error', summary: 'a context index whose id is not a GUID' },
+    AGENT_CONTEXT_QUERY_NOT_EXPRESSION: { severity: 'error', summary: 'a context index query that is neither a prompt nor an expression' },
+    AGENT_MEMORY_NOT_AUTHORABLE: { severity: 'error', summary: 'an inline agent that attaches memory, which the platform does not serve' },
+    CALL_NO_NUMBER: { severity: 'error', summary: 'a createOutgoingCall step with no from or to number' },
+    CALL_NUMBER_NOT_E164: { severity: 'warning', summary: 'a createOutgoingCall number that is not E.164' },
+    CONV_AGENT_CUSTOM_NO_ID: { severity: 'error', summary: "a conversational agent in 'custom' mode with no conversationId" },
+    CONV_AGENT_NO_MODEL: { severity: 'error', summary: 'a conversational agent with no model' },
+    CONV_AGENT_NO_PROMPT: { severity: 'error', summary: 'a conversational agent with no systemPrompt' },
+    CONV_AGENT_NO_TURN: { severity: 'error', summary: 'a conversational agent whose settings bind nothing' },
+    CONV_AGENT_SETTINGS_MODE: { severity: 'error', summary: "a conversational agent whose settings mode is neither 'simple' nor 'custom'" },
+    GUARDRAIL_ACTION_UNKNOWN: { severity: 'error', summary: 'a guardrail whose action type is unknown' },
+    GUARDRAIL_DUP_ID: { severity: 'error', summary: 'two guardrails with one id' },
+    GUARDRAIL_INCOMPLETE: { severity: 'error', summary: 'a guardrail missing a required field' },
+    GUARDRAIL_NO_RULES: { severity: 'error', summary: 'a custom guardrail with no rules' },
+    GUARDRAIL_NO_SCOPE: { severity: 'error', summary: 'a guardrail whose selector names no scope' },
+    GUARDRAIL_NO_VALIDATOR: { severity: 'error', summary: 'a built-in validator guardrail with no validatorType' },
+    GUARDRAIL_TYPE_UNKNOWN: { severity: 'error', summary: 'a guardrail whose type is unknown' },
+    INLINE_AGENT_COMPOSITE_INPUT: { severity: 'error', summary: 'an inline agent input bound to a computed expression' },
+    INLINE_AGENT_EMPTY_RETURNS: { severity: 'warning', summary: 'an inline agent with returns: {}' },
+    INLINE_AGENT_ESCALATION_APP_KEY_NOT_GUID: { severity: 'error', summary: 'an app escalation whose app key is not a GUID' },
+    INLINE_AGENT_ESCALATION_APP_WITH_FIELDS: { severity: 'error', summary: 'an app escalation that also lists quick-form fields' },
+    INLINE_AGENT_ESCALATION_FIELD_OPTIONS: { severity: 'error', summary: 'a quick-form escalation field whose options are invalid' },
+    INLINE_AGENT_ESCALATION_FIELD_OPTIONS_IGNORED: { severity: 'warning', summary: 'a quick-form escalation field with options its type ignores' },
+    INLINE_AGENT_ESCALATION_FIELD_SETTING_INVALID: { severity: 'error', summary: 'a quick-form escalation field with an invalid setting' },
+    INLINE_AGENT_ESCALATION_FIELD_TYPE_UNKNOWN: { severity: 'error', summary: 'a quick-form escalation field of an unknown type' },
+    INLINE_AGENT_ESCALATION_NO_APP: { severity: 'error', summary: 'an app escalation with no app' },
+    INLINE_AGENT_ESCALATION_NO_FIELDS: { severity: 'error', summary: 'a quick-form escalation with no fields' },
+    INLINE_AGENT_ESCALATION_NO_NAME: { severity: 'error', summary: 'an escalation with no name' },
+    INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP: { severity: 'error', summary: 'a quick-form escalation that also names an app' },
+    INLINE_AGENT_ESCALATION_VARIANT: { severity: 'error', summary: 'an escalation whose variant is unknown' },
+    INLINE_AGENT_INPUT_NAME_AMBIGUOUS: { severity: 'warning', summary: 'two inline agent inputs that reach the platform under one name' },
+    INLINE_AGENT_MEMORY_ID_NOT_GUID: { severity: 'error', summary: 'an agent memory whose id is not a GUID' },
+    INLINE_AGENT_MEMORY_INCOMPLETE: { severity: 'error', summary: 'an agent memory missing its name or id' },
+    INLINE_AGENT_NO_MODEL: { severity: 'error', summary: 'an inline agent with no model' },
+    INLINE_AGENT_NO_SYSTEM_PROMPT: { severity: 'error', summary: 'an inline agent with no systemPrompt' },
+    INLINE_AGENT_NO_USER_PROMPT: { severity: 'error', summary: 'an inline agent with no userPrompt' },
+    INLINE_AGENT_PROMPT_JSON_TEXT: { severity: 'error', summary: 'an inline agent prompt that asks for JSON text' },
+    INLINE_AGENT_READ_NOT_OUTPUT: { severity: 'error', summary: 'an inline agent read outside output' },
+    INLINE_AGENT_READ_UNKNOWN_FIELD: { severity: 'error', summary: 'an inline agent read of a field returns does not declare' },
+    INLINE_AGENT_RESOURCE_NODE_ID: { severity: 'error', summary: "an agent resource nodeId that is blank or another node's" },
+    INLINE_AGENT_RESOURCE_SOURCE_DUP: { severity: 'error', summary: 'two agent resources, or two agents, with one source' },
+    INLINE_AGENT_RESOURCE_SOURCE_NOT_GUID: { severity: 'error', summary: 'an agent resource source that is not a uuid' },
+    INLINE_AGENT_SCAFFOLD_MODEL: { severity: 'warning', summary: "an inline agent on the platform scaffold's model" },
+    INLINE_AGENT_SOURCE_NOT_GUID: { severity: 'error', summary: 'an inline agent source that is not a uuid' },
+    INLINE_AGENT_TOOL_A2A_INCOMPLETE: { severity: 'error', summary: 'an a2a tool missing its name, slug or key' },
+    INLINE_AGENT_TOOL_CLIENTSIDE_NO_NAME: { severity: 'error', summary: 'a client-side tool with no name' },
+    INLINE_AGENT_TOOL_CONNECTOR_NO_CONNECTION: { severity: 'error', summary: 'a connector tool with no connection or folder' },
+    INLINE_AGENT_TOOL_HTTP_METHOD: { severity: 'error', summary: 'an HTTP-request tool with an unknown method' },
+    INLINE_AGENT_TOOL_IXP_NO_NAME: { severity: 'error', summary: 'an IxP tool with no name' },
+    INLINE_AGENT_TOOL_IXP_PROJECT_NOT_GUID: { severity: 'error', summary: 'an IxP tool whose projectId is not a uuid' },
+    INLINE_AGENT_TOOL_KEY_NOT_GUID: { severity: 'error', summary: 'a process tool whose key is not a GUID' },
+    INLINE_AGENT_TOOL_MCP_INCOMPLETE: { severity: 'error', summary: 'an MCP tool missing its name or key' },
+    INLINE_AGENT_TOOL_NO_OPERATION: { severity: 'error', summary: 'a connector tool with no connector or operation' },
+    INLINE_AGENT_TOOL_NO_RESOURCE_ID: { severity: 'error', summary: 'a process tool with no name or folderPath' },
+    INLINE_AGENT_TOOL_UNKNOWN_BUILTIN: { severity: 'error', summary: 'a builtin tool that is not one of the three' },
+    INLINE_AGENT_TOOL_UNKNOWN_KIND: { severity: 'error', summary: 'a tool of an unknown kind' },
+    INLINE_AGENT_UNDECLARED_PLACEHOLDER: { severity: 'error', summary: 'a prompt placeholder naming no declared input' },
+    INLINE_AGENT_UNREFERENCED_INPUT: { severity: 'warning', summary: 'an inline agent input no prompt references' },
+    VOICE_AGENT_ITERATIONS: { severity: 'error', summary: 'a voice agent whose maxIterations is outside 1 to 8' },
+    VOICE_AGENT_NO_PROMPT: { severity: 'error', summary: 'a voice agent with no systemPrompt' },
+    VOICE_CALL_CONTEXT_NOT_OBJECT: { severity: 'error', summary: 'a voice step whose callContext reads a field inside the context' },
+    VOICE_MODEL_UNKNOWN: { severity: 'error', summary: "a voice agent naming a voice model outside the platform's catalog" },
+    VOICE_NO_CALL_CONTEXT: { severity: 'error', summary: 'an endCall or voice agent step with no callContext' },
+    VOICE_PERSONA_UNKNOWN: { severity: 'error', summary: "a voice agent persona that is not one of its model's voices" },
+};
+/**
+ * A conversational AGENT step (Phase 5).
+ *
+ * The turn wiring is the whole risk: `'simple'` mode reads everything out of
+ * ONE conversation-context binding, so a flow that names neither the context
+ * nor the individual fields deploys an agent with no transcript to answer.
+ */
+export function checkConversationalAgent(inputs, ctx) {
+    const step = ctx.step;
+    const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
+    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
+    if (blank(inputs?.model)) {
+        at('CONV_AGENT_NO_MODEL', `Conversational agent step "${step}" has no \`model\`, which the node's definition requires. `
+            + `\`uip agent model list\` shows what the tenant offers.`, `model: 'gpt-5.4'`);
+    }
+    if (blank(inputs?.systemPrompt)) {
+        at('CONV_AGENT_NO_PROMPT', `Conversational agent step "${step}" has no \`systemPrompt\` — the agent has no instructions for how `
+            + `to answer the person.`, `systemPrompt: 'You are a support agent. Be brief.'`);
+    }
+    const st = inputs?.settings;
+    const mode = st?.mode ?? 'simple';
+    if (mode !== 'simple' && mode !== 'custom') {
+        at('CONV_AGENT_SETTINGS_MODE', `Conversational agent step "${step}"'s settings mode is ${JSON.stringify(mode)}. Valid: 'simple' (one `
+            + `conversation-context binding) or 'custom' (bind each field yourself).`);
+        return;
+    }
+    const named = ['context', 'conversationId', 'exchangeId', 'messages', 'userSettings']
+        .filter((k) => st !== undefined && !blank(st[k]));
+    if (named.length === 0) {
+        at('CONV_AGENT_NO_TURN', `Conversational agent step "${step}" binds nothing in \`settings\` — it would run with no transcript and `
+            + `no conversation to answer into. In 'simple' mode bind the whole context from a wait or context step.`, `settings: { context: out('<waitStep>', 'conversationContext') }`);
+    }
+    else if (mode === 'custom' && blank(st?.conversationId)) {
+        at('CONV_AGENT_CUSTOM_NO_ID', `Conversational agent step "${step}" binds its turn field-by-field ('custom' mode) but names no `
+            + `\`conversationId\` — the one field the platform's own editor marks required, because the reply has `
+            + `nowhere to go without it.`, `settings: { mode: 'custom', conversationId: out('start', 'conversationId'), … }`);
+    }
+}
+/**
+ * A VOICE step (Phase 5D): create-outgoing-call, end-call, or the voice agent.
+ *
+ * Two things are decidable offline and expensive later: a call needs both
+ * numbers in a form the telephony provider accepts, and every voice step needs
+ * the `callContext` OBJECT — binding a bare conversation id instead is the
+ * classic mistake, because the field is typed `object` and a string passes the
+ * file's schema while failing at dispatch.
+ */
+export function checkVoice(kind, inputs, ctx) {
+    const step = ctx.step;
+    const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
+    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
+    if (kind === 'createOutgoingCall') {
+        for (const field of ['from', 'to']) {
+            const raw = inputs?.[field];
+            if (blank(raw)) {
+                at('CALL_NO_NUMBER', `createOutgoingCall step "${step}" has no \`${field}\`, which the node's schema requires — `
+                    + `${field === 'from' ? 'the provisioned number the call comes from' : 'the number to dial'}.`, `${field}: '+15551234567'`);
+                continue;
+            }
+            // A literal number is checkable; an expression is the caller's business.
+            if (typeof raw === 'string' && !/^\+[1-9]\d{6,14}$/.test(raw.trim())) {
+                at('CALL_NUMBER_NOT_E164', `createOutgoingCall step "${step}"'s \`${field}\` is ${JSON.stringify(raw)}, which is not `
+                    + `E.164 (a leading '+' and 7–15 digits). Telephony providers reject anything else at dispatch, `
+                    + `so a run fails after the flow is deployed.`, `${field}: '+15551234567'`);
+            }
+        }
+        return;
+    }
+    // end-call and the voice agent are both keyed by the live call.
+    if (blank(inputs?.callContext)) {
+        at('VOICE_NO_CALL_CONTEXT', `${kind === 'endCall' ? 'endCall' : 'voiceAgent'} step "${step}" has no \`callContext\`, which the node's `
+            + `schema requires — it identifies the live call. The incoming-call trigger publishes it as `
+            + `out('start', 'callContext'), and createOutgoingCall as out('<dialStep>', 'callContext').`, `callContext: out('start', 'callContext')`);
+    }
+    else {
+        const cc = inputs.callContext;
+        const js = cc instanceof Expr && !cc.literal ? cc.js : undefined;
+        // The field is the call-context OBJECT. A read that ends at a scalar inside
+        // it (`…callContext.conversationId`, or a bare conversation id) passes the
+        // file's schema and then fails at dispatch.
+        if (js !== undefined && /\.(conversationId|id)\s*$/.test(js)) {
+            at('VOICE_CALL_CONTEXT_NOT_OBJECT', `${kind === 'endCall' ? 'endCall' : 'voiceAgent'} step "${step}"'s \`callContext\` reads `
+                + `"${js.trim()}", which is a field INSIDE the call context rather than the context object itself. `
+                + `The node's schema types it \`object\`; a scalar passes the file's schema and fails at dispatch.`, `callContext: out('start', 'callContext')`);
+        }
+    }
+    if (kind === 'voiceAgent') {
+        if (blank(inputs?.systemPrompt)) {
+            at('VOICE_AGENT_NO_PROMPT', `voiceAgent step "${step}" has no \`systemPrompt\` — a caller is waiting, and the agent has no `
+                + `instructions for what to say.`, `systemPrompt: 'Greet the caller and find out why they called.'`);
+        }
+        const mi = inputs?.maxIterations;
+        if (mi !== undefined && !(mi instanceof Expr)) {
+            const n = Number(mi);
+            if (!Number.isInteger(n) || n < 1 || n > 8) {
+                at('VOICE_AGENT_ITERATIONS', `voiceAgent step "${step}"'s \`maxIterations\` is ${JSON.stringify(mi)}. The node's schema allows `
+                    + `1 to 8 — a tighter ceiling than a text agent's, because the caller is waiting on the turn.`, `maxIterations: 4`);
+            }
+        }
+        const v = inputs?.voice;
+        if (v !== undefined) {
+            const PERSONAS = {
+                'gemini-3.1-flash-live-preview': ['Aoede', 'Charon', 'Fenrir', 'Kore', 'Leda', 'Orus', 'Puck', 'Zephyr'],
+                'gpt-realtime-2': ['alloy', 'ash', 'ballad', 'coral', 'echo', 'sage', 'shimmer', 'verse'],
+            };
+            const model = typeof v.model === 'string' ? v.model : undefined;
+            // An own-key read: `in` also matched 'toString', and `PERSONAS[model].includes` then threw.
+            const personas = model !== undefined ? ownEntry(PERSONAS, model) : undefined;
+            if (model !== undefined && personas === undefined) {
+                at('VOICE_MODEL_UNKNOWN', `voiceAgent step "${step}" names the voice model ${JSON.stringify(model)}. The platform's catalog `
+                    + `today is ${Object.keys(PERSONAS).map((m) => `'${m}'`).join(' and ')} — a voice model, not one of `
+                    + `the text models an inline agent takes.`);
+            }
+            else if (typeof v.persona === 'string' && personas !== undefined && !personas.includes(v.persona)) {
+                at('VOICE_PERSONA_UNKNOWN', `voiceAgent step "${step}"'s persona ${JSON.stringify(v.persona)} is not one of `
+                    + `${JSON.stringify(model)}'s voices (${personas.join(', ')}). A persona belongs to its model.`);
+            }
+        }
+    }
+}
+// ─── an inline agent's prompt asking for JSON text ───────────────────────────────
+//
+// The phrase table behind `INLINE_AGENT_PROMPT_JSON_TEXT`. It is kept narrow on
+// purpose, because the rule is an error. Three shapes count, and each skips a
+// negation anywhere earlier in the same clause ("Do not return JSON", "Do not wrap
+// the answer in JSON", "Return the items, not as JSON"):
+//
+//  - DIRECT: an output verb, then only words from a closed qualifier list, then
+//    `json` — "Return ONLY a JSON object", "Return only the typed JSON contract".
+//  - VIA: an output verb, up to two words, then `as` / `in` / `with`, qualifiers,
+//    `json` — "Format your answer as JSON", "Respond with valid JSON".
+//  - BRACE: a quoted-key brace whose key is one of the step's own `returns` keys —
+//    `Return ONLY {"category","priority"}` next to `returns: { category, priority }`.
+//
+// A word outside the qualifier list ends a DIRECT match, so JSON as DATA does not
+// count in the DIRECT form: "Answer the question using the JSON data below", "Give
+// a summary of the JSON ticket", "Return the invoice number from the JSON". The VIA
+// form allows two free words, so it can still fire on JSON as a topic ("Answer in
+// Spanish with JSON examples"); the tail skips the common data nouns after `json`
+// (keys, data, record, examples, input) and the JSON-family FORMATS a string field
+// legitimately holds (JSON Schema, JSON Patch, JSON-LD, JSON Lines, …). `write` is
+// not a verb here: "You help users write JSON" is a topic, not an answer shape.
+//
+// The skills repo's preview-doc gate (tests/tasks/uipath-maestro-flow/_shared/
+// test_preview_inline_agent_prompts.py) ports this table to Python and loads a
+// byte-identical copy of tests/fixtures/inline-agent-prompt-vectors.json, so
+// change the table, the fixture and the port together.
+const JSON_TEXT_VERBS = 'return|respond|reply|output|answer|produce|emit|format|give|provide';
+/** Words that are only ever qualifiers of the answer's shape, never the thing it is about. */
+const JSON_TEXT_QUALIFIERS = [
+    'only', 'just', 'exactly', 'strictly', 'solely', 'simply', 'a', 'an', 'one', 'single', 'the',
+    'your', 'its', 'this', 'that', 'valid', 'raw', 'pure', 'plain', 'strict', 'compact', 'minified',
+    'well-formed', 'properly', 'formatted', 'typed', 'declared', 'structured', 'following', 'same',
+    'final', 'back', 'proper', 'correct', 'machine-readable', 'parseable', 'parsable',
+];
+/** A negation anywhere earlier in the same clause, or anywhere in the match's gap. */
+const JSON_TEXT_NEGATIONS = new Set(['not', 'never', 'no', 'dont', 'without', 'rather', 'instead', 'avoid']);
+const isJsonTextNegation = (w) => JSON_TEXT_NEGATIONS.has(w) || w.endsWith("n't") || w.endsWith('n’t');
+const JSON_TEXT_WORD = "[A-Za-z][\\w'’-]*";
+/** Words are separated by spaces, tabs or a comma — never a newline or a full stop. */
+const JSON_TEXT_SEP = '[ \\t]*,?[ \\t]+';
+const JSON_TEXT_QUAL = `(?:${[...JSON_TEXT_QUALIFIERS].sort((a, b) => b.length - a.length).join('|')})\\b`;
+// `(?<![-\w])` skips `--output json`; `(?!\.\w)` skips `JSON.parse` / `JSON.stringify`;
+// `(?!-(?:ld|rpc)\b)` skips JSON-LD / JSON-RPC (`\b` matches before the hyphen);
+// the last lookahead skips "the JSON below" / "the JSON provided" / "the JSON you
+// get", data nouns ("the JSON keys", "JSON examples") and JSON-family formats
+// ("JSON Schema", "JSON Patch", "the JSON path", "a JSON Web Token").
+const JSON_TEXT_TAIL = `json\\b(?!\\.\\w)(?!-(?:ld|rpc)\\b)(?![ \\t]+(?:below|above|provided|given|you`
+    + `|keys?|data|records?|examples?|inputs?`
+    + `|schemas?|patch|path|pointer|lines|rpc|web[ \\t]+tokens?)\\b)`;
+const JSON_TEXT_VERB = `(?<![-\\w])(?:${JSON_TEXT_VERBS})\\b`;
+const JSON_TEXT_DIRECT = new RegExp(`${JSON_TEXT_VERB}((?:${JSON_TEXT_SEP}${JSON_TEXT_QUAL}){0,5})${JSON_TEXT_SEP}${JSON_TEXT_TAIL}`, 'gi');
+const JSON_TEXT_VIA = new RegExp(`${JSON_TEXT_VERB}((?:${JSON_TEXT_SEP}${JSON_TEXT_WORD}){0,2}?)${JSON_TEXT_SEP}(?:as|in|with)`
+    + `((?:${JSON_TEXT_SEP}${JSON_TEXT_QUAL}){0,4})${JSON_TEXT_SEP}${JSON_TEXT_TAIL}`, 'gi');
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * The phrase in `text` that tells a model to answer in JSON TEXT, or `undefined`.
+ *
+ * `check` uses it for `INLINE_AGENT_PROMPT_JSON_TEXT`, passing the step's `returns`
+ * keys so the brace form only counts a brace that spells one of them. Without
+ * `returnKeys` (the example and doc sweeps) any quoted identifier key counts.
+ * `{{input.*}}` placeholders are removed first, so an input named `json` never
+ * matches.
+ *
+ * @example
+ * ```ts
+ * jsonTextDirective('Return ONLY a JSON object with keys "subject" and "body".'); // 'Return ONLY a JSON'
+ * jsonTextDirective('Return ONLY {"category","priority"}.', ['category']);       // '{"category",'
+ * jsonTextDirective('Return a result conforming to the output schema.');          // undefined
+ * jsonTextDirective('Do not return JSON.');                                       // undefined
+ * jsonTextDirective('Answer the question using the JSON data below.');            // undefined
+ * ```
+ */
+export function jsonTextDirective(text, returnKeys) {
+    if (typeof text !== 'string' || text === '')
+        return undefined;
+    // A placeholder becomes a hard break (`·` is neither a word nor a gap), and a
+    // quoted or back-ticked `JSON` is read as the bare word.
+    const t = text
+        .replace(/\{\{\s*input\.[^}]*\}\}/g, ' · ')
+        .replace(/[`"'“”](json)[`"'“”]/gi, ' $1 ');
+    const words = (s) => (s.match(new RegExp(JSON_TEXT_WORD, 'g')) ?? []).map((w) => w.toLowerCase());
+    const keys = returnKeys?.length ? returnKeys.map(escapeRegExp).join('|') : '[A-Za-z_]\\w*';
+    const brace = new RegExp(`\\{[ \\t]*["'](?:${keys})["'][ \\t]*[,:}]`, 'g');
+    for (const rule of [JSON_TEXT_DIRECT, JSON_TEXT_VIA, brace]) {
+        rule.lastIndex = 0;
+        for (const m of t.matchAll(rule)) {
+            if (m.slice(1).some((g) => words(g ?? '').some(isJsonTextNegation)))
+                continue;
+            // Any negation earlier in the same clause: "Do not wrap the answer in JSON",
+            // "No need to return JSON". A comma ends a clause, so "Do not guess, return
+            // ONLY a JSON object" still counts.
+            const clause = t.slice(0, m.index).split(/[.;:!?\n,]/).pop() ?? '';
+            if (words(clause).some(isJsonTextNegation))
+                continue;
+            return m[0].trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Check an `inlineAgent(...)` call.
+ *
+ * The interesting difference from every other node this SDK authors: **nothing here
+ * lives on a tenant.** An inline agent's whole contract is in the call, so these
+ * rules can be certain rather than best-effort — the definition's own `required`
+ * list is checkable, and so is whether the prompts and the declared variables agree.
+ *
+ * Three rules exist because the PLATFORM does something with what you wrote:
+ *
+ *  - `INLINE_AGENT_SCAFFOLD_MODEL` — the model the platform's own scaffold ships is
+ *    stale, and v1's smoke check for this node type fails a flow that keeps it. A
+ *    warning, not an error: it is a real model id, it just should not be a default
+ *    nobody chose.
+ *  - `INLINE_AGENT_UNREFERENCED_INPUT` — flow-v1 derives the deployed input list by
+ *    scanning the PROMPTS for `$vars.*` references and only falls back to the
+ *    authored `agentInputVariables` when that pre-pass did not run. So a declared
+ *    input the prompts never mention is pruned deployed while arriving locally: a
+ *    disagreement between rungs and the platform, which is the one class that has to
+ *    be said out loud rather than left to a run.
+ *  - `INLINE_AGENT_PROMPT_JSON_TEXT` — the platform returns `returns` as a typed
+ *    object: it becomes the `agent.json` `outputSchema`, and the agent runtime ends
+ *    a run with a structured call that fills exactly those fields. A prompt that
+ *    ALSO asks for JSON text makes the model pack its whole answer, serialized, into
+ *    one string field. See {@link jsonTextDirective}.
+ */
+export function checkInlineAgent(inputs, ctx) {
+    const step = ctx.step;
+    const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
+    const warn = (code, message) => ctx.report(code, message);
+    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
+    // `memory` is authorable in this SDK and NOT authorable on the platform. The
+    // bundled `uipath.agent.autonomous@1.4` carries a `memory` handle added by
+    // #431; the tenant's own manifest for that node type declares only
+    // `escalation, context, tool, success, error`, and the registry index (4977
+    // entries, 2026-09-09) contains NO `uipath.agent.resource.memory.*` type at
+    // all — so both halves of what `memory` emits are unknown to the platform.
+    // `context` is not the alternative: those resources are knowledge INDEXES
+    // (`…context.index.<slug>.<guid>`), i.e. context grounding, not episodic memory.
+    //
+    // Compile succeeds and `uip maestro flow validate` then hard-refuses the edge:
+    //
+    //   [edges[edge_0].sourcePort] Edge references source handle "memory" on node
+    //   "triage", but the current manifest for "uipath.agent.autonomous" does not
+    //   declare that handle … Retry: RetryWillNotFix
+    //
+    // An artifact that compiles and can never validate is the worst of the two
+    // failures, so this is said here — before the emit — rather than left to a rung.
+    // It is an ERROR because there is no spelling that works today, and `--no-check`
+    // remains the escape for a tenant whose manifest does declare the handle.
+    if (inputs?.memory !== undefined) {
+        at('AGENT_MEMORY_NOT_AUTHORABLE', `Inline agent step "${step}" attaches \`memory\`, which the platform cannot resolve: the tenant's `
+            + `\`uipath.agent.autonomous\` manifest declares no \`memory\` handle (only escalation, context, tool, `
+            + `success, error) and the registry serves no \`uipath.agent.resource.memory.*\` node type. The flow `
+            + `compiles and then fails \`uip maestro flow validate\` as RetryWillNotFix. Drop \`memory\`; for `
+            + `retrieval over a knowledge source use a context index instead (\`tools\`/context grounding). `
+            + `Pass --no-check only on a tenant whose manifest does declare the handle.`);
+    }
+    // A context `query` is what the RUNTIME searches with, and it is not an
+    // expression slot. A plain string is the model-invoked `dynamic` variant: the
+    // text becomes the description the model reads before it writes its own query.
+    // An expression renders as the `static` variant instead, whose `value` the
+    // retriever is handed VERBATIM — there is no `$vars` scope inside the agent and
+    // nothing templates it once `uip agent refresh` has stripped the node, so the
+    // search runs on the literal text `=js:$vars…`. With the default `threshold: 0`
+    // it still returns chunks, so it reads as working while retrieving on nonsense.
+    // Refused rather than emitted until the argument-bound form is implemented
+    // (`{ variant: 'argument' }`, which the runtime resolves from agent state).
+    const contexts = inputs?.context === undefined ? []
+        : Array.isArray(inputs.context) ? inputs.context : [inputs.context];
+    for (const cx of contexts) {
+        if (cx?.query !== undefined && typeof cx.query !== 'string') {
+            at('AGENT_CONTEXT_QUERY_NOT_EXPRESSION', `Inline agent step "${step}" gives its context index "${cx.name ?? ''}" an EXPRESSION \`query\`. `
+                + `The runtime searches with that value literally — it is not evaluated inside the agent — so `
+                + `retrieval runs on the text of the expression and quietly returns unrelated chunks. Use a plain `
+                + `string: it becomes the guidance the model reads before writing its own query, which is what a `
+                + `run-dependent search needs.`);
+        }
+    }
+    // The index id is half of the resource node's TYPE
+    // (`…context.index.<slug>.<id>`), and the platform resolves the index by it.
+    // A blank, padded or non-GUID id builds a type no tenant serves, and nothing
+    // downstream says so: the flow compiles, merges and validates, and the agent
+    // runs ungrounded. So it is an error, not a warning. The id is tested as
+    // written, not trimmed, because serialize emits it as written.
+    for (const cx of contexts) {
+        const id = typeof cx?.id === 'string' ? cx.id : '';
+        if (!GUID_RE.test(id)) {
+            at('AGENT_CONTEXT_NO_ID', `Inline agent step "${step}" grounds on context index "${cx?.name ?? ''}" with `
+                + (id.trim() === '' ? 'no `id`'
+                    : GUID_RE.test(id.trim()) ? `\`id\` ${JSON.stringify(cx?.id)}, which has whitespace around the GUID`
+                        : `\`id\` ${JSON.stringify(cx?.id)}, which is not a GUID`) + '. '
+                + `The id is the index's key: it is the tail of the resource node's type and how the runtime finds `
+                + `the index, so without a real one the agent runs ungrounded and \`validate\` does not notice. `
+                + `\`uip solution resources list --kind Index --source remote --search "<name>"\` returns it as \`Key\`.`);
+        }
+    }
+    // An index outside the deployment folder needs its folder named. The resource
+    // file carries no `indexId`, so `indexName` + `folderPath` is the whole locator,
+    // and `@uipath/tool-agent`'s `createIndexBinding` leaves the folder off the
+    // binding when `folderPath` is empty. A WARNING, not an error: an index in the
+    // deployment folder resolves without it.
+    for (const cx of contexts) {
+        if (cx != null && cx.folderPath === undefined) {
+            warn('AGENT_CONTEXT_NO_FOLDER_PATH', `Inline agent step "${step}" grounds on context index "${cx.name ?? ''}" without a \`folderPath\`. `
+                + `The emitted resource carries no index id, so the folder is half of how the runtime finds the `
+                + `index, and the binding is written without one. Give the index's folder — `
+                + `\`uip solution resources list --kind Index --source remote --search "<name>"\` returns it.`);
+        }
+    }
+    // The definition's own `required`: systemPrompt, userPrompt, model — each with
+    // `minLength: 1`, so a blank string is as invalid as a missing key.
+    if (blank(inputs?.model)) {
+        at('INLINE_AGENT_NO_MODEL', `Inline agent step "${step}" has no \`model\`. The node's definition requires one (\`minLength: 1\`), so `
+            + `a flow without it does not validate. \`uip agent model list\` shows what the tenant offers.`, `model: 'gpt-5.4'`);
+    }
+    if (blank(inputs?.systemPrompt)) {
+        at('INLINE_AGENT_NO_SYSTEM_PROMPT', `Inline agent step "${step}" has no \`systemPrompt\`. The node's definition requires one `
+            + `(\`minLength: 1\`). It is where the agent is told what it is and what shape to answer in.`);
+    }
+    if (blank(inputs?.userPrompt)) {
+        at('INLINE_AGENT_NO_USER_PROMPT', `Inline agent step "${step}" has no \`userPrompt\`. The node's definition requires one `
+            + `(\`minLength: 1\`). It is the per-run request.`);
+    }
+    const model = typeof inputs?.model === 'string' ? inputs.model.trim() : '';
+    if (model === 'gpt-4o-2024-11-20') {
+        warn('INLINE_AGENT_SCAFFOLD_MODEL', `Inline agent step "${step}" uses \`gpt-4o-2024-11-20\` — the model the platform's own scaffold ships, `
+            + `and the one v1's smoke check for this node type FAILS a flow for keeping (it is the definition's `
+            + `\`inputDefaults.model\`, not a choice). Pick a current model: \`uip agent model list\`.`);
+    }
+    // Where each resource node sits (`nodeId`, `source`): decompile writes them
+    // for a node the canvas placed, and compile writes them as given. A blank or
+    // repeated id would make compile refuse the flow or overwrite another node,
+    // and a `source` that is not a uuid names a directory the platform does not
+    // expect (the agent's own `source` has the same rule).
+    const asList = (v) => (v === undefined ? [] : Array.isArray(v) ? v : [v]);
+    const placed = [
+        ...asList(inputs?.context).map((r) => ({ what: `context index "${r?.name ?? ''}"`, kind: 'Context', nodeId: r?.nodeId, source: r?.source })),
+        ...asList(inputs?.tools).map((r) => ({ what: `${r?.kind ?? ''} tool`, kind: 'Tool', nodeId: r?.nodeId, source: r?.source })),
+        ...asList(inputs?.escalation).map((r) => ({ what: `escalation "${r?.name ?? ''}"`, kind: 'Escalation', nodeId: r?.nodeId, source: r?.source })),
+    ];
+    // The ids compile derives for the resources with no `nodeId`: the n-th one of
+    // a kind gets `<step><Kind>`, then `<step><Kind>2`, ... An explicit id equal to
+    // one of them makes compile refuse the flow, or rename the derived node.
+    for (const kind of ['Context', 'Tool', 'Escalation']) {
+        const derived = placed.filter((r) => r.kind === kind && r.nodeId === undefined);
+        derived.forEach((r, n) => {
+            const id = derivedResourceNodeId(step, kind, n);
+            ctx.resources.derivedNodeId(id, `the id compile derives for the ${r.what} of inline agent step "${step}"`);
+        });
+    }
+    /** Explicit `source` -> the resource on THIS agent that has it: two would write one resource.json. */
+    const sources = new Map();
+    for (const r of placed) {
+        if (r.nodeId !== undefined) {
+            const id = typeof r.nodeId === 'string' ? r.nodeId : '';
+            let other;
+            if (id.trim() === '') {
+                at('INLINE_AGENT_RESOURCE_NODE_ID', `Inline agent step "${step}" gives its ${r.what} the \`nodeId\` ${JSON.stringify(r.nodeId)}, which is `
+                    + `not a node id. Omit \`nodeId\` to derive one, or give the id the node has in the flow.`);
+            }
+            else if ((other = ctx.resources.claimNodeId(id, r.what)) !== undefined) {
+                at('INLINE_AGENT_RESOURCE_NODE_ID', `Inline agent step "${step}" gives its ${r.what} the \`nodeId\` "${id}", which the ${other.what} `
+                    + `(on step "${other.step}") already has. Node ids are unique in a flow.`);
+            }
+        }
+        if (r.source === undefined)
+            continue;
+        // Not trimmed: compile writes `source` as given, into `inputs.source` and the directory name.
+        if (!GUID_RE.test(String(r.source))) {
+            at('INLINE_AGENT_RESOURCE_SOURCE_NOT_GUID', `Inline agent step "${step}" gives its ${r.what} the \`source\` ${JSON.stringify(r.source)}, which is not `
+                + `a uuid${/^\s|\s$/.test(String(r.source)) ? ' (it has spaces around it)' : ''}. \`source\` is the resource's `
+                + `directory under the agent's own (\`resources/<source>/resource.json\`) and the node's \`inputs.source\`. `
+                + 'Omit it and one is derived from the flow id, the step and the resource.');
+            continue;
+        }
+        const key = String(r.source).toLowerCase();
+        const first = sources.get(key);
+        if (first !== undefined) {
+            at('INLINE_AGENT_RESOURCE_SOURCE_DUP', `Inline agent step "${step}" gives its ${first} and its ${r.what} the same \`source\` "${String(r.source)}". `
+                + 'Both would write `resources/<source>/resource.json` under this agent, and the second file would replace '
+                + 'the first. Give each resource its own `source`, or omit `source` to derive one.');
+        }
+        else {
+            sources.set(key, r.what);
+        }
+    }
+    if (typeof inputs?.source === 'string' && GUID_RE.test(inputs.source.trim())) {
+        const other = ctx.resources.claimFolder(inputs.source.trim());
+        if (other !== undefined) {
+            at('INLINE_AGENT_RESOURCE_SOURCE_DUP', `Inline agent steps "${other}" and "${step}" have the same \`source\` "${inputs.source}". Both would write `
+                + '`<source>/agent.json`, and the second file would replace the first. Give each agent its own `source`, '
+                + 'or omit it to derive one.');
+        }
+    }
+    if (inputs?.source !== undefined && !GUID_RE.test(String(inputs.source).trim())) {
+        at('INLINE_AGENT_SOURCE_NOT_GUID', `Inline agent step "${step}"'s \`source\` is ${JSON.stringify(inputs.source)}, which is not a uuid. `
+            + `\`source\` is the agent's own DIRECTORY name, and the platform resolves its configuration at `
+            + `"<source>/agent.json" — a non-uuid name is not what the designer or the runtime expect. Omit it and `
+            + `one is derived from the flow id and step name (stable across recompiles).`);
+    }
+    if (inputs?.returns && Object.keys(inputs.returns).length === 0) {
+        warn('INLINE_AGENT_EMPTY_RETURNS', `Inline agent step "${step}" declares \`returns: {}\`. That is not "no output" — it falls back to the `
+            + `definition's default, \`{ content: 'string' }\`, which is the scaffold shape. Declare the fields the `
+            + `agent must return, or drop the key and read \`content\`.`);
+    }
+    // A prompt that asks for JSON TEXT while `returns` declares the fields. The
+    // platform already returns those fields as a typed object — `returns` is the
+    // agent.json `outputSchema`, and the runtime ends a run with a structured call
+    // that fills exactly those keys — so the extra directive does not shape the
+    // answer, it gets serialized INTO it: on 2026-09-23 a writer declaring
+    // `{ subject, body }` came back with `body` = '{"subject":…,"body":…}' in 3 of 3
+    // debug runs, and the flow mailed the JSON. `uip maestro flow validate` accepts
+    // the prompt (it never reads prompt meaning), so this is where it is said. An
+    // ERROR for the same reason `INLINE_AGENT_UNDECLARED_PLACEHOLDER` is one: the
+    // platform accepts the shape and the run still delivers the wrong value, and a
+    // warning is printed past while compile writes the .flow anyway. Only when
+    // `returns` is declared: with the `{ content }` default, JSON text in `content`
+    // may be exactly what the author reads back.
+    const returnKeys = Object.keys(inputs?.returns ?? {});
+    if (returnKeys.length) {
+        for (const field of ['systemPrompt', 'userPrompt']) {
+            const phrase = jsonTextDirective(String(inputs?.[field] ?? ''), returnKeys);
+            if (phrase === undefined)
+                continue;
+            const rewrite = `Return a result conforming to the output schema. `
+                + returnKeys.map((k) => `${k}: <what it holds>.`).join(' ');
+            at('INLINE_AGENT_PROMPT_JSON_TEXT', `Inline agent step "${step}"'s \`${field}\` tells the model to answer in JSON text ("${phrase}"), `
+                + `but \`returns\` already declares the answer: ${returnKeys.map((k) => `\`${k}\``).join(', ')}. `
+                + `The platform returns those fields as a typed object — \`returns\` becomes the agent.json `
+                + `\`outputSchema\`, and the agent runtime ends each run with a structured call that fills exactly `
+                + `those keys — so \`out('${step}', '${returnKeys[0]}')\` reads a value, not text to parse. Asking `
+                + `for JSON as well makes the model pack its whole answer, serialized, into one string field (for `
+                + `example a \`body\` that reads '{"subject":…,"body":…}'). Replace only that JSON instruction (keep the rest `
+                + `of the prompt) with one line per field, in the platform's own wording: "${rewrite}" Declare a field \`'object'\` or `
+                + `\`'array'\` if it should carry structure. \`uip maestro flow validate\` accepts this prompt, so `
+                + `nothing later catches it. If this is a false positive (the prompt only mentions JSON as data), `
+                + `compile with --no-check.`);
+        }
+    }
+    // The prompts-vs-variables agreement, in both directions. Both prompts are
+    // searched, because flow-v1's pre-pass scans both.
+    const prompts = `${String(inputs?.systemPrompt ?? '')}\n${String(inputs?.userPrompt ?? '')}`;
+    const placeholders = [...prompts.matchAll(/\{\{\s*input\.([A-Za-z_$][A-Za-z0-9_$]*)\s*\}\}/g)]
+        .map((m) => m[1]);
+    const declaredInputs = Object.keys(inputs?.inputs ?? {});
+    // Direction 1: a declared input no prompt references. The platform may prune it,
+    // in which case the agent receives nothing and the authored list sits unused.
+    const unreferenced = declaredInputs.filter((k) => !placeholders.includes(k));
+    if (declaredInputs.length && unreferenced.length === declaredInputs.length) {
+        warn('INLINE_AGENT_UNREFERENCED_INPUT', `Inline agent step "${step}" declares input(s) ${unreferenced.map((u) => `\`${u}\``).join(', ')} that `
+            + `neither prompt references as \`{{input.<name>}}\` — so NONE of them is referenced. Deployed, the `
+            + `authored list is not necessarily what the platform sends: flow-v1's `
+            + `\`preDeriveAgentInputDefinitions\` pre-pass builds the input list by scanning the node's prompts for `
+            + `variable references, merges what it finds with the authored list, and DROPS an entry no reference `
+            + `points at when its caller asks for pruning. A referenced input survives every path; an unreferenced `
+            + `one survives only some, and the failure mode is an agent that arrives with no arguments at all. `
+            + `Write \`{{input.${declaredInputs[0]}}}\` in a prompt — which is also how the agent gets told what it `
+            + `is looking at.`);
+    }
+    else if (unreferenced.length) {
+        warn('INLINE_AGENT_UNREFERENCED_INPUT', `Inline agent step "${step}" declares input(s) ${unreferenced.map((u) => `\`${u}\``).join(', ')} that `
+            + `neither prompt references as \`{{input.<name>}}\`. The platform may prune an unreferenced input, so `
+            + `it is not reliably sent — and an input the prompts never mention is one the agent cannot use anyway.`);
+    }
+    // Direction 2: a placeholder naming an input that does not exist. The compiler
+    // leaves it alone rather than deleting it, so it reaches the model as the literal
+    // text `{{input.x}}` — visible, but not what anyone meant.
+    const undeclared = [...new Set(placeholders.filter((p) => !declaredInputs.includes(p)))];
+    if (undeclared.length) {
+        at('INLINE_AGENT_UNDECLARED_PLACEHOLDER', `Inline agent step "${step}" references ${undeclared.map((u) => `\`{{input.${u}}}\``).join(', ')} in a `
+            + `prompt, but \`inputs\` declares ${declaredInputs.length ? declaredInputs.map((d) => `\`${d}\``).join(', ') : 'nothing'}. `
+            + `An unmatched placeholder is not substituted — it reaches the model as that literal text, and the `
+            + `value it was meant to carry never arrives.`, declaredInputs.length
+            ? `inputs: { ${undeclared[0]}: input('${undeclared[0]}'), … }`
+            : `inputs: { ${undeclared[0]}: input('${undeclared[0]}') }`);
+    }
+    // Direction 3: an input bound to a COMPUTED EXPRESSION rather than to one
+    // reference. The platform names each of an agent's arguments after the
+    // reference path it is bound to (the shell node's `agentInputVariables`), so
+    // an expression spanning zero or several references has no single argument —
+    // and therefore no name a `{{input.<x>}}` token could address. The compiler
+    // declares no argument for it, so its value does not reach the agent, and the
+    // placeholder reaches the model as literal text. An error rather than a
+    // warning, and for the same reason `INLINE_AGENT_UNDECLARED_PLACEHOLDER` is
+    // one: the value never arrives.
+    for (const [name, val] of Object.entries(inputs?.inputs ?? {})) {
+        if (!(val instanceof Expr) || val.literal)
+            continue;
+        if (flatNameOf(val.js) !== undefined)
+            continue;
+        if (!placeholders.includes(name))
+            continue;
+        at('INLINE_AGENT_COMPOSITE_INPUT', `Inline agent step "${step}"'s input \`${name}\` is bound to a computed expression `
+            + `(\`${val.js.length > 60 ? `${val.js.slice(0, 60)}…` : val.js}\`), and a prompt references it as `
+            + `\`{{input.${name}}}\`. The platform does not send the agent the names you declared: it names each `
+            + `argument after the REFERENCE PATH the input is bound to (\`$vars.a.output.b\` → \`a__output__b\`). `
+            + `A computed expression is not one reference, so it gets no argument: its value does not reach the `
+            + `agent, and the placeholder reaches the model as that literal text.`, `compute it in a script step first, then bind the step's output: `
+            + `.step('${name}Value', script({ code: 'return …;' })) … inputs: { ${name}: out('${name}Value') }`);
+    }
+    // A step id containing `__` makes the flat name AMBIGUOUS on the platform: the
+    // encoding joins path segments with `__` and v1's own inverse (`decodeFlatName`)
+    // documents that it round-trips only while ids "disallow `__`". A warning, not
+    // an error — the argument is still SENT and our token still matches it, so the
+    // agent works; what breaks is anything that decodes the name back to a path
+    // (the CLI's `hydrateInlineAgentInputs` reconcile, and the designer).
+    for (const [name, val] of Object.entries(inputs?.inputs ?? {})) {
+        if (!(val instanceof Expr) || val.literal)
+            continue;
+        const segments = flatNameSegmentsOf(val.js);
+        const offender = segments?.find((s) => s.includes(FLAT_SEP));
+        if (!offender)
+            continue;
+        warn('INLINE_AGENT_INPUT_NAME_AMBIGUOUS', `Inline agent step "${step}"'s input \`${name}\` reads \`${val.js}\`, whose path segment `
+            + `\`${offender}\` contains \`${FLAT_SEP}\`. The platform names the argument by joining the path's `
+            + `segments with \`${FLAT_SEP}\` (\`${segments.join(FLAT_SEP)}\`), so that name no longer says where `
+            + `the value came from — v1's own inverse round-trips only while ids avoid \`${FLAT_SEP}\`. The `
+            + `argument is still sent and the prompt still reads it; what breaks is anything decoding the name `
+            + `back to a path. Rename the step or variable to drop the double underscore.`);
+    }
+    // GUARDRAILS (Phase 4F). The node's definition types the input only as
+    // `array`, so a malformed entry deploys silently and either never trips or
+    // blocks every run — both invisible until production. The shapes below are
+    // Agent Builder's own discriminators.
+    const rails = inputs?.guardrails;
+    if (rails !== undefined) {
+        const ids = new Set();
+        rails.forEach((g, i) => {
+            const label = g?.name ? `"${g.name}"` : `guardrails[${i}]`;
+            if (!g || (g.$guardrailType !== 'custom' && g.$guardrailType !== 'builtInValidator')) {
+                at('GUARDRAIL_TYPE_UNKNOWN', `Inline agent step "${step}"'s ${label} has the $guardrailType `
+                    + `${JSON.stringify(g?.$guardrailType)}. Valid: 'custom' `
+                    + `(rules you author) or 'builtInValidator' (a platform validator).`);
+                return;
+            }
+            if (blank(g.id) || blank(g.name)) {
+                at('GUARDRAIL_INCOMPLETE', `Inline agent step "${step}"'s ${label} is missing ${blank(g.id) ? 'an id' : 'a name'} — `
+                    + `both are required by the agent schema (the id keys the rail, the name is what trips show).`);
+                return;
+            }
+            if (ids.has(g.id)) {
+                at('GUARDRAIL_DUP_ID', `Inline agent step "${step}" declares the guardrail id "${g.id}" twice — the second silently `
+                    + `shadows the first in Agent Builder's keyed storage.`);
+                return;
+            }
+            ids.add(g.id);
+            if (!Array.isArray(g.selector?.scopes) || g.selector.scopes.length === 0) {
+                at('GUARDRAIL_NO_SCOPE', `Inline agent step "${step}"'s guardrail "${g.name}" selects no scopes — it can never apply.`, `selector: { scopes: ['Agent'] }`);
+            }
+            const act = g.action?.$actionType;
+            if (act !== 'block' && act !== 'filter' && act !== 'log') {
+                at('GUARDRAIL_ACTION_UNKNOWN', `Inline agent step "${step}"'s guardrail "${g.name}" has the action ${JSON.stringify(act)}. `
+                    + `Valid: 'block', 'filter', 'log'.`);
+            }
+            if (g.$guardrailType === 'custom' && (!Array.isArray(g.rules) || g.rules.length === 0)) {
+                at('GUARDRAIL_NO_RULES', `Inline agent step "${step}"'s custom guardrail "${g.name}" has no rules — nothing can ever `
+                    + `trip it, so the action never fires.`, `rules: [{ $ruleType: 'always', applyTo: 'inputAndOutput' }]`);
+            }
+            if (g.$guardrailType === 'builtInValidator' && blank(g.validatorType)) {
+                at('GUARDRAIL_NO_VALIDATOR', `Inline agent step "${step}"'s guardrail "${g.name}" names no validatorType — the platform `
+                    + `cannot resolve which built-in validator to run.`);
+            }
+        });
+    }
+    // TOOLS and ESCALATION (card G16). Cheap identity checks only: a wrong KIND
+    // or a non-uuid KEY emits a node type the tenant has never heard of, which
+    // nothing downstream of the compiler can see — the resource is dropped from
+    // emitted graph, so no rung ever exercises it. Library resolution for connector
+    // tools happens at compile (where the library is), not here.
+    const toolRefs = inputs?.tools === undefined ? []
+        : Array.isArray(inputs.tools) ? inputs.tools : [inputs.tools];
+    const BUILTIN_TOOLS = ['analyzefiles', 'summarize', 'batchtransform'];
+    for (const t of toolRefs) {
+        const kind = t?.kind;
+        if (kind === 'builtin') {
+            if (!BUILTIN_TOOLS.includes(String(t.tool))) {
+                at('INLINE_AGENT_TOOL_UNKNOWN_BUILTIN', `Inline agent step "${step}" declares a builtin tool ${JSON.stringify(t.tool)}. `
+                    + `The platform ships exactly three: ${BUILTIN_TOOLS.map((b) => `'${b}'`).join(', ')} — the node type is a `
+                    + `fixed string, so any other name is a node the tenant has never heard of.`, `{ kind: 'builtin', tool: 'summarize' }`);
+            }
+        }
+        else if (kind === 'connector') {
+            const c = t;
+            if (blank(c.connector) || blank(c.operation)) {
+                at('INLINE_AGENT_TOOL_NO_OPERATION', `Inline agent step "${step}" declares a connector tool without ${blank(c.connector) ? 'a `connector`' : 'an `operation`'}. `
+                    + `Both name the curated-library entry the tool is resolved from — the same pair \`connector(…)\` takes.`, `{ kind: 'connector', connector: 'uipath-atlassian-jira', operation: 'create-issue' }`);
+            }
+            // A connector tool calls Integration Service on a CONNECTION, exactly as a
+            // connector step does — and before #867 there was no way to give it one, so
+            // the tool compiled with none anywhere (no binding, no resource.json row)
+            // and could only fail at run time. Both halves, as `registry prepare` writes them.
+            const labels = t;
+            const missing = ['connection', 'folder'].filter((k) => blank(labels[k]));
+            if (missing.length > 0) {
+                const key = blank(c.connector) ? '<connector-key>' : String(c.connector);
+                const op = blank(c.operation) ? '<operation>' : String(c.operation);
+                at('INLINE_AGENT_TOOL_CONNECTOR_NO_CONNECTION', `Inline agent step "${step}"'s connector tool "${key}/${op}" has no ${missing.map((m) => `\`${m}\``).join(' or ')}. `
+                    + `The tool calls Integration Service on a tenant connection: without one the agent's tool has no `
+                    + `connection binding, its resource.json carries none, and the solution's Resources never list it. `
+                    + `Name the bindings.json labels the same way \`connector()\` takes them — \`${prepareCommand(key, op)}\` `
+                    + `finds the connection and writes both entries.`, `{ kind: 'connector', connector: '${key}', operation: '${op}', connection: '<connection label>', folder: '<folder label>' }`);
+            }
+            else {
+                ctx.bindingLabels(`Inline agent step "${step}"'s connector tool`, labels, undefined, blank(c.connector) ? undefined : { key: String(c.connector), ...(blank(c.operation) ? {} : { action: String(c.operation) }) });
+            }
+        }
+        else if (kind === 'ixp') {
+            const x = t;
+            if (blank(x.projectId) || !GUID_RE.test(String(x.projectId).trim())) {
+                at('INLINE_AGENT_TOOL_IXP_PROJECT_NOT_GUID', `Inline agent step "${step}"'s IxP tool has \`projectId\` ${JSON.stringify(x.projectId)}, which is not a uuid. `
+                    + `It is the node type's tail (uipath.agent.resource.tool.ixp.<slug>.<projectId>), so a wrong one emits a `
+                    + `node type the tenant cannot resolve. Find it: uip maestro flow registry pull --force && `
+                    + `uip maestro flow registry search -f "type:startsWith=uipath.agent.resource.tool.ixp".`);
+            }
+            if (blank(x.name)) {
+                at('INLINE_AGENT_TOOL_IXP_NO_NAME', `Inline agent step "${step}"'s IxP tool needs a \`name\` — the project's display name, which the definition `
+                    + `carries as both its label and \`inputDefaults.name\`.`);
+            }
+        }
+        else if (kind === 'process' || kind === 'agent' || kind === 'api' || kind === 'flow'
+            || kind === 'maestro' || kind === 'function') {
+            const p = t;
+            if (blank(p.key) || !GUID_RE.test(String(p.key).trim())) {
+                at('INLINE_AGENT_TOOL_KEY_NOT_GUID', `Inline agent step "${step}"'s '${String(kind)}' tool has \`key\` ${JSON.stringify(p.key)}, which is not a uuid. `
+                    + `The key IS the node type's tail (uipath.agent.resource.tool.…<key>), so a wrong one emits a node type `
+                    + `the tenant cannot resolve. Find it: uip maestro flow registry search "uipath.agent.resource.tool".`);
+            }
+            if (blank(p.name) || blank(p.folderPath)) {
+                at('INLINE_AGENT_TOOL_NO_RESOURCE_ID', `Inline agent step "${step}"'s '${String(kind)}' tool needs both \`name\` and \`folderPath\` — they form the `
+                    + `binding's resourceKey ("<folderPath>.<name>"), which is how the deployed flow finds the resource.`);
+            }
+        }
+        else if (kind === 'mcp') {
+            const m = t;
+            if (blank(m.name) || blank(m.key) || !GUID_RE.test(String(m.key).trim())) {
+                at('INLINE_AGENT_TOOL_MCP_INCOMPLETE', `Inline agent step "${step}"'s MCP tool needs a \`name\` and a uuid \`key\` — the node type is minted `
+                    + `from them (uipath.agent.resource.tool.mcp.<name>.<key>) and the key is the reference the runtime `
+                    + `resolves.`);
+            }
+        }
+        else if (kind === 'a2a') {
+            const a = t;
+            if (blank(a.name) || blank(a.key) || !GUID_RE.test(String(a.key).trim()) || blank(a.slug)) {
+                at('INLINE_AGENT_TOOL_A2A_INCOMPLETE', `Inline agent step "${step}"'s remote-A2A tool needs \`name\`, a uuid \`key\`, and \`slug\` — the node `
+                    + `type is minted from name+key, and the runtime resolves the remote agent by slug (the platform's own `
+                    + `mapper refuses a blank one).`);
+            }
+        }
+        else if (kind === 'clientside') {
+            if (blank(t.name)) {
+                at('INLINE_AGENT_TOOL_CLIENTSIDE_NO_NAME', `Inline agent step "${step}"'s client-side tool has no \`name\` — it is what the model calls, and the `
+                    + `calling application dispatches on it.`);
+            }
+        }
+        else if (kind === 'httpRequest') {
+            const h = t;
+            const m = h.method === undefined ? undefined : String(h.method).toUpperCase();
+            if (m !== undefined && !['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(m)) {
+                at('INLINE_AGENT_TOOL_HTTP_METHOD', `Inline agent step "${step}"'s HTTP-request tool fixes the method to ${JSON.stringify(h.method)}. The `
+                    + `tool's contract allows GET, POST, PUT, PATCH, DELETE — anything else the runtime refuses at call time.`);
+            }
+        }
+        else {
+            at('INLINE_AGENT_TOOL_UNKNOWN_KIND', `Inline agent step "${step}" declares a tool with kind ${JSON.stringify(kind)}. Valid kinds: 'builtin', `
+                + `'connector', 'process', 'agent', 'api', 'flow', 'maestro', 'function', 'ixp', 'mcp', 'a2a', `
+                + `'clientside', 'httpRequest'.`);
+        }
+    }
+    const escalations = inputs?.escalation === undefined ? []
+        : Array.isArray(inputs.escalation) ? inputs.escalation : [inputs.escalation];
+    for (const e of escalations) {
+        if (blank(e?.name)) {
+            at('INLINE_AGENT_ESCALATION_NO_NAME', `Inline agent step "${step}" declares an escalation without a \`name\`. The node's definition requires one `
+                + `(\`minLength: 1\`).`);
+        }
+        if (e?.variant !== undefined && e.variant !== 'quick-form') {
+            at('INLINE_AGENT_ESCALATION_VARIANT', `Inline agent step "${step}"'s escalation names the variant ${JSON.stringify(e.variant)}. Valid: `
+                + `'quick-form' — or omit it for the app-backed default.`);
+            continue;
+        }
+        if (e?.variant === 'quick-form') {
+            // The form lives INLINE: an app would be emitted and ignored, and a form
+            // with nothing to fill in is a notification nobody can answer.
+            if (e.app !== undefined) {
+                at('INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP', `Inline agent step "${step}"'s quick-form escalation also names an app. The form lives in the flow — `
+                    + `drop \`app\`, or drop the variant for the app-backed escalation.`);
+            }
+            if (!Array.isArray(e.fields) || e.fields.length === 0) {
+                at('INLINE_AGENT_ESCALATION_NO_FIELDS', `Inline agent step "${step}"'s quick-form escalation declares no \`fields\` — the reviewer gets an `
+                    + `empty form.`);
+            }
+            for (const f of Array.isArray(e.fields) ? e.fields : []) {
+                if (!FORM_FIELD_TYPES.includes(String(f?.type))) {
+                    at('INLINE_AGENT_ESCALATION_FIELD_TYPE_UNKNOWN', `Inline agent step "${step}"'s quick-form escalation gives the field "${String(f?.id ?? '?')}" the type `
+                        + `${JSON.stringify(f?.type)}, ${formFieldTypeWhy(f?.type, `which the form does not recognize — it would `
+                            + `be published as a plain string`)}. Valid: ${validFormFieldTypesText()}.`, formFieldTypeHint(f?.type));
+                }
+                const optionsProblem = formFieldOptionsProblem(f);
+                if (optionsProblem !== undefined) {
+                    const message = `Inline agent step "${step}"'s quick-form escalation field "${String(f?.id ?? '?')}" `
+                        + `${formFieldOptionsWhy(optionsProblem, f?.type)}.`;
+                    if (optionsProblem === 'ignored')
+                        warn('INLINE_AGENT_ESCALATION_FIELD_OPTIONS_IGNORED', message);
+                    else {
+                        at('INLINE_AGENT_ESCALATION_FIELD_OPTIONS', message, `options: [{ id: 'opt-1', value: 'high', label: 'High' }, { id: 'opt-2', value: 'low', label: 'Low' }]`);
+                    }
+                }
+                for (const problem of formFieldSettingProblems(f)) {
+                    at('INLINE_AGENT_ESCALATION_FIELD_SETTING_INVALID', `Inline agent step "${step}"'s quick-form escalation gives the field "${String(f?.id ?? '?')}" `
+                        + `${problem}. The platform refuses the form.`);
+                }
+            }
+            continue;
+        }
+        if (e?.fields !== undefined) {
+            at('INLINE_AGENT_ESCALATION_APP_WITH_FIELDS', `Inline agent step "${step}"'s escalation declares inline \`fields\`, but its form belongs to the deployed `
+                + `app. Use variant: 'quick-form' for an inline form.`);
+        }
+        if (blank(e?.app?.key) || blank(e?.app?.name)) {
+            at('INLINE_AGENT_ESCALATION_NO_APP', `Inline agent step "${step}"'s escalation needs \`app.key\` and \`app.name\` — the deployed Action Center app `
+                + `that carries the review task. An escalation with no app is a task nobody can open.`);
+        }
+        else if (!GUID_RE.test(String(e.app.key).trim())) {
+            at('INLINE_AGENT_ESCALATION_APP_KEY_NOT_GUID', `Inline agent step "${step}"'s escalation \`app.key\` is ${JSON.stringify(e.app.key)}, which is not a uuid. `
+                + `It is the app's own key on the tenant, not its name.`);
+        }
+    }
+    // MEMORY (Phase 5A): identity is required — the node type is minted from it.
+    const mem = inputs?.memory;
+    if (mem !== undefined) {
+        if (blank(mem.name) || blank(mem.id)) {
+            at('INLINE_AGENT_MEMORY_INCOMPLETE', `Inline agent step "${step}"'s memory needs both \`name\` and \`id\` — the node type is minted from them `
+                + `(uipath.agent.resource.memory.<name>.<id>) and the runtime resolves the memory by id.`);
+        }
+        else if (!GUID_RE.test(String(mem.id).trim())) {
+            at('INLINE_AGENT_MEMORY_ID_NOT_GUID', `Inline agent step "${step}"'s memory \`id\` is ${JSON.stringify(mem.id)}, which is not a uuid. It is the `
+                + `memory's own id on the tenant, not its name.`);
+        }
+    }
+}
+/**
+ * A read of an inline agent's output: `out('<step>', '<field>')`.
+ *
+ * Stricter than the published families' equivalent, and it can afford to be: the
+ * declared `returns` IS the contract (there is no tenant to disagree with), and it
+ * is what any runner has to coerce the model's completion to: build
+ * `{ <declared keys> }` and put the raw completion in the first one if the model
+ * ignored the shape. So a read outside the set is undefined by construction, not
+ * merely probably.
+ */
+export function checkInlineAgentRead({ node: name, field, rest, reader: step }, spec, report) {
+    if (field === undefined)
+        return;
+    if (field === 'error')
+        return;
+    if (field !== 'output') {
+        report('INLINE_AGENT_READ_NOT_OUTPUT', `Inline agent "${name}" publishes its answer under "output", but "$vars.${name}.${field}" (read in `
+            + `"${step}") asks for "${field}", which is undefined at run time.`, `out('${name}', '<field>')`);
+        return;
+    }
+    // The default when `returns` is omitted is the definition's own.
+    const declared = spec.returns && Object.keys(spec.returns).length
+        ? Object.keys(spec.returns)
+        : ['content'];
+    const wanted = (rest ?? '').replace(/^\./, '').split('.')[0];
+    if (!wanted)
+        return;
+    if (declared.includes(wanted))
+        return;
+    const nearest = nearestName(wanted, declared);
+    report('INLINE_AGENT_READ_UNKNOWN_FIELD', `Inline agent "${name}" declares no output "${wanted}" (read as "$vars.${name}.output.${wanted}" in `
+        + `"${step}"). Its \`returns\` names: ${declared.join(', ')}`
+        + `${spec.returns && Object.keys(spec.returns).length ? '' : ' (the definition\'s default, because the step declares no `returns`)'}`
+        + `. Unlike a published agent's, this contract is yours — the node's \`agentOutputVariables\` are these `
+        + `names, and the engine coerces the model's completion to exactly them, so a read outside the set is `
+        + `undefined by construction.`, nearest ? `out('${name}', '${nearest}')` : undefined);
+}