@uipath/maestro-builder-sdk 6.42.0 → 6.44.0

package/dist/nodes/agent/flow/resources.d.ts

@@ -0,0 +1,502 @@
+import type { ContextIndexRef, EscalationRef } from '../../../core/actions.js';
+import type { ResolvedConnector } from '../../../core/library.js';
+import type { ProcessResourceSubType } from '../../../core/process-resource.js';
+/** The inline (autonomous) agent's node type — fixed, not per-instance. */
+export declare const INLINE_AGENT = "uipath.agent.autonomous";
+/**
+ * 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.
+ */
+export declare function contextIndexDef(spec: {
+    name: string;
+    id: string;
+}): any;
+/**
+ * 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.
+ */
+export declare function renderContextQuery(query: unknown, render: (value: unknown) => unknown): Record<string, unknown>;
+/**
+ * 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.
+ */
+export declare function contextResourceJson(cx: ContextIndexRef, spec: {
+    id: string;
+    query: Record<string, unknown>;
+}): Record<string, unknown>;
+/** A `fieldSchema` object with every declared property marked required. */
+export declare function requireAll(schema: {
+    type: string;
+    properties: Record<string, unknown>;
+}): Record<string, unknown>;
+/**
+ * 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.
+ */
+export declare function toolResourceJson(tr: any, spec: {
+    id: string;
+}): Record<string, unknown> | undefined;
+/** `inline` → `Inline`: the node's enum spelling to the resource schema's. */
+export declare const enumValue: (v: unknown) => string;
+/**
+ * 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`.
+ */
+export declare function builtinToolResourceJson(tool: string, label: string, inputs: Record<string, any>, spec: {
+    id: string;
+}): Record<string, unknown> | undefined;
+/**
+ * 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.
+ */
+export declare const HTTP_REQUEST_FIELDS: ReadonlyArray<readonly [string, Record<string, unknown>]>;
+/**
+ * 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.
+ */
+export declare function httpRequestToolResourceJson(label: string, inputs: Record<string, any>, spec: {
+    id: string;
+    canvasNodeId: string;
+}): Record<string, unknown>;
+/**
+ * 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.
+ */
+export declare const DOTNET_TYPE: Record<string, string>;
+/**
+ * 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.
+ */
+export declare function escalationAppFolder(app: {
+    folderPath?: string;
+}): string;
+/**
+ * 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.
+ */
+export declare function escalationResourceJson(esc: EscalationRef, spec: {
+    id: string;
+    channelId: string;
+    quickFormSchema?: Record<string, unknown>;
+}): Record<string, unknown>;
+/**
+ * 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.*' }]`.
+ */
+export declare function toolInputHandle(): any;
+/** A `{ name: type }` field map as the JSON-schema object the platform stores. */
+export declare function fieldSchema(fields: Record<string, string> | undefined): any;
+/**
+ * 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.
+ */
+export declare const BUILTIN_TOOL_DEFS: Record<string, any>;
+/**
+ * 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.
+ */
+export declare function connectorToolDef(rc: ResolvedConnector): any;
+/** What a connector tool's resource.json is built from. */
+export interface ConnectorToolContext {
+    rc: ResolvedConnector;
+    detail: Record<string, any>;
+    name: string;
+    description: string;
+    iconUrl: string;
+}
+/** The folder key a connection with no folder binding carries in its resource.json. */
+export declare 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.
+ */
+export declare function connectorToolDescription(rc: ResolvedConnector): string;
+/**
+ * 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.
+ */
+export declare function promptChip(f: {
+    description?: string;
+    displayName?: string;
+    name: string;
+}): string;
+export declare const isPromptChip: (v: unknown) => boolean;
+/** The text inside `{{prompt: "…"}}`, read the way the product reads it (maestro-sdk PROMPT_UNWRAPPER); `''` when `value` is not a chip. */
+export declare function chipText(value: string): string;
+/** A field's enum as `{ name, value }` rows, the platform's spelling; `undefined` when it has none. */
+export declare function enumRows(raw: unknown): Array<{
+    name: string;
+    value: string;
+}> | undefined;
+/**
+ * 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.
+ */
+export declare function connectorToolDetail(rc: ResolvedConnector, conn: string | undefined, folder: string | undefined, seed: string): Record<string, any>;
+/** Walk (creating) the object chain for a dotted field name; returns the parent schema and the leaf key. */
+export declare function nestedSlot(root: Record<string, any>, name: string): {
+    parent: Record<string, any>;
+    leaf: string;
+};
+/**
+ * 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.
+ */
+export declare function connectorToolResourceJson(ctx: ConnectorToolContext, id: string): Record<string, unknown>;
+/**
+ * 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.
+ */
+export declare const PROCESS_TOOL_META: Record<string, {
+    ns: string;
+    serviceType: string;
+    subType: ProcessResourceSubType;
+    orchestratorType: string;
+    category: string;
+    icon: string;
+    sortOrder: number;
+}>;
+/**
+ * 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.
+ */
+export declare function processToolDef(kind: string, spec: {
+    key: string;
+    name: string;
+    folderPath: string;
+    inputs?: Record<string, string>;
+    returns?: Record<string, string>;
+}): any;
+/**
+ * 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.
+ */
+export declare function ixpToolDef(spec: {
+    projectId: string;
+    name: string;
+    description?: string;
+    versionTag?: string;
+    attachment?: {
+        mode?: string;
+        description?: string;
+        argumentPath?: string;
+    };
+}): any;
+/**
+ * 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.
+ */
+export declare function escalationDef(): any;
+/**
+ * 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.
+ */
+export declare function mcpToolDef(spec: {
+    name: string;
+    key: string;
+    description?: string;
+    folderPath?: string;
+    folderKey?: string;
+    mcpType?: string;
+    serviceName?: string;
+    slug?: string;
+    selectedTools?: unknown[];
+}): any;
+/**
+ * The definition for ONE remote-A2A tool resource, mirrored from
+ * `transformRemoteA2aResource` — same provenance and slug rule as the MCP def.
+ */
+export declare function a2aToolDef(spec: {
+    name: string;
+    key: string;
+    slug: string;
+    description?: string;
+    cachedAgentCard?: Record<string, unknown> | null;
+    resourceType?: string | null;
+    folderPath?: string;
+    folderKey?: string;
+    resourceFolderPath?: string;
+}): any;
+/**
+ * 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.
+ */
+export declare function memoryResourceDef(spec: {
+    name: string;
+    id: string;
+    description?: string;
+    folderKey?: string;
+}): any;
+/** True when a definition declares the agent's `memory` artifact handle. */
+export declare function declaresMemoryHandle(def: any): boolean;
+/**
+ * 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.
+ */
+export declare function inlineAgentDef(version: string, withMemory: boolean, resolve: (type: string, version: string) => any): any;