@uipath/maestro-builder-sdk 6.21.2 → 6.23.0

package/dist/decompile.js

@@ -38,6 +38,7 @@ import { commentText } from './core/comment-text.js';
 import { tsLiteral, tsNumber, tsText } from './core/ts-literal.js';
 import { contextIndexSlug, parseContextIndexType } from './core/context-index.js';
 import { wireExprBody } from './core/wire-expr.js';
+import { hasExits } from './core/step-ports.js';
 import { parseIxpProjectType } from './core/actions.js';
 import { readFlowGlobals } from './flow-variables.js';
 import { outputBackingGlobal, outputBackingName } from './flow-output-backing.js';
@@ -228,16 +229,12 @@ const T = {
     hitlQuickForm: 'uipath.human-in-the-loop.quick-form',
     hitlActionApp: 'uipath.human-in-the-loop.coded-action-app',
     hitlDocValidation: 'uipath.human-in-the-loop.document-validation',
-    summarize: 'uipath.pattern.deep-rag',
-    batchTransform: 'uipath.pattern.batch-transform',
     sendMessage: 'uipath.conversational.send-message',
     waitForMessage: 'uipath.conversational.wait-for-message',
     conversationContext: 'uipath.conversational.get-conversation-context',
     triggerVoice: 'core.trigger.voice',
     createOutgoingCall: 'uipath.conversational.voice.create-outgoing-call',
     endCall: 'uipath.conversational.voice.end-call',
-    http: 'core.action.http',
-    httpV2: 'core.action.http.v2',
     decision: 'core.logic.decision',
     switch: 'core.logic.switch',
     merge: 'core.logic.merge',
@@ -547,21 +544,29 @@ function specValue(raw) {
     return raw;
 }
 /**
- * Print a node whose type is registered (flow-node-registry.ts): the node type
- * deserializes it to its spec and prints the factory call. A node at a version
- * the type does not register is lifted by its default version's implementation —
- * as every built-in family lifts any version — and `verClause` omits a
- * `{ version }` the type does not register, with a warning. `undefined` when the type is not registered, or the node type declines
- * the node; the caller's branches take it from there.
+ * The registered implementation a node of this type and version lifts with: its
+ * own version's, else the type's default (as every built-in family lifts any
+ * version); undefined when the type is not registered.
  */
-function emitRegisteredSpec(node, imp, inputNames) {
+function registeredImpl(node) {
     const entry = typeof node.type === 'string' ? FLOW_NODE_TYPES.byTypeName(node.type) : undefined;
     if (!entry)
         return undefined;
     const version = String(node.typeVersion ?? '');
-    const impl = (Object.hasOwn(entry.type.versions, version)
+    return (Object.hasOwn(entry.type.versions, version)
         ? entry.type.versions[version]
         : entry.type.versions[entry.type.defaultVersion]);
+}
+/**
+ * A node of a registered type (flow-node-registry.ts), lifted to its spec by the
+ * type's own `deserialize`: undefined when the type is not registered or declines
+ * the node. A node at a version the type does not register is lifted by its
+ * default version's implementation, as every built-in family lifts any version.
+ */
+function liftRegistered(node, impl = registeredImpl(node)) {
+    if (!impl)
+        return undefined;
+    const version = String(node.typeVersion ?? '');
     const ctx = {
         nodeId: node.id,
         expr: specValue,
@@ -574,8 +579,21 @@ function emitRegisteredSpec(node, imp, inputNames) {
         warn: warnOnce,
     };
     const spec = impl.deserialize(node, ctx);
-    if (spec === undefined)
+    return spec === undefined ? undefined : { impl, spec };
+}
+/**
+ * Print a node whose type is registered (flow-node-registry.ts): the node type
+ * deserializes it to its spec and prints the factory call. A node at a version
+ * the type does not register is lifted by its default version's implementation —
+ * as every built-in family lifts any version — and `verClause` omits a
+ * `{ version }` the type does not register, with a warning. `undefined` when the type is not registered, or the node type declines
+ * the node; the caller's branches take it from there.
+ */
+function emitRegisteredSpec(node, imp, inputNames) {
+    const lifted = liftRegistered(node);
+    if (!lifted)
         return undefined;
+    const { impl, spec } = lifted;
     // A spec value as source, recursing into arrays and plain objects so an Expr
     // nested in one (a filter row's value) prints as the helper an author writes —
     // in the `{ k: v }` / `[a, b]` spelling the hand-written printers use.
@@ -617,7 +635,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
     const lifted = emitRegisteredSpec(node, imp, inputNames);
     if (lifted !== undefined)
         return lifted;
-    const inputs = node.inputs ?? {};
     switch (node.type) {
         case T.createOutgoingCall:
         case T.endCall: {
@@ -642,30 +659,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
         case T.hitlActionApp:
         case T.hitlDocValidation:
             return emitHitl(node, imp, inputNames, graph);
-        case T.summarize:
-        case T.batchTransform: {
-            const attachment = emitVal(inputs.attachment, imp, inputNames);
-            const prompt = emitVal(inputs.prompt, imp, inputNames);
-            if (node.type === T.summarize) {
-                return `${imp.use('summarize')}(${opts([
-                    ['attachment', attachment],
-                    ['prompt', prompt],
-                    // Both flags default to false in the emitted node; only `true` was authored.
-                    ['returnCitations', unwrapPlain(inputs.returnCitations) === true ? 'true' : undefined],
-                ])})`;
-            }
-            const cols = Array.isArray(inputs.outputColumns) ? inputs.outputColumns : [];
-            const colSrc = `[${cols.map((c) => opts([
-                ['name', emitVal(c.name, imp, inputNames)],
-                ['description', emitVal(c.description, imp, inputNames)],
-            ])).join(', ')}]`;
-            return `${imp.use('batchTransform')}(${opts([
-                ['attachment', attachment],
-                ['prompt', prompt],
-                ['outputColumns', colSrc],
-                ['enableWebSearchGrounding', unwrapPlain(inputs.enableWebSearchGrounding) === true ? 'true' : undefined],
-            ])})`;
-        }
         case T.sendMessage:
         case T.waitForMessage:
         case T.conversationContext: {
@@ -707,10 +700,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 ['exchangeLimit', num(i.exchangeLimit) === '20' ? undefined : num(i.exchangeLimit)],
             ])})`;
         }
-        case T.http:
-            return emitHttp(node, false, imp, inputNames);
-        case T.httpV2:
-            return emitHttp(node, true, imp, inputNames);
         default:
             // A connector action node: `uipath.connector.<key>.<action>` (but NOT the
             // event nodes `uipath.connector.event.*` / `.trigger.*`, which are triggers).
@@ -767,66 +756,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
             return unsupportedSpec(node, imp, o);
     }
 }
-/**
- * Invert an HTTP node. The plain node (`core.action.http`) keeps its request at
- * the top level (`url` / `method` / `headers` / `queryParams` / `body` /
- * `contentType`); the managed node (`core.action.http.v2`) nests the request
- * inside `detail.bodyParameters` and routes through IS. Request settings
- * (`timeout` / `retryCount`) sit at the top level on both. Emitted only-when-off
- * their definition defaults, exactly as serialize writes them, so the round-trip
- * stays minimal. The response schema (`returns`) is a Phase-2 refinement.
- */
-function emitHttp(node, managed, imp, inputNames) {
-    const inputs = node.inputs ?? {};
-    const detail = managed
-        ? (inputs.detail ?? {})
-        : {};
-    const req = managed
-        ? detail.bodyParameters ?? {}
-        : inputs;
-    const method = typeof req.method === 'string' ? req.method : 'GET';
-    const headers = managed ? req.headers : inputs.headers;
-    const query = managed ? req.query : inputs.queryParams;
-    const bodySrc = req.body !== undefined && req.body !== '' ? emitVal(req.body, imp, inputNames) : undefined;
-    const headersSrc = emitValMap(headers, imp, inputNames) || undefined;
-    const querySrc = emitValMap(query, imp, inputNames) || undefined;
-    const contentType = !managed && typeof inputs.contentType === 'string' && inputs.contentType !== 'application/json'
-        ? tsLiteral(inputs.contentType) : undefined;
-    const timeout = typeof inputs.timeout === 'string' && inputs.timeout !== 'PT15M' ? tsLiteral(inputs.timeout) : undefined;
-    const retry = inputs.retryCount !== undefined && Number(inputs.retryCount) !== 0 ? tsNumber(inputs.retryCount) : undefined;
-    const branchRows = Array.isArray(inputs.branches) ? inputs.branches : [];
-    const branchesSrc = branchRows.length
-        ? `[${branchRows.map((b) => {
-            const cond = unwrapSource(b.conditionExpression) ?? '';
-            const expr = emitBareExpr(wireExprBody(cond), imp, inputNames);
-            return `{ name: ${tsText(b.name ?? b.id)}, condition: ${expr} }`;
-        }).join(', ')}]`
-        : undefined;
-    const connectionValue = detail.connectionId ?? detail.connectionResourceId ?? req.connection;
-    const connection = managed && typeof connectionValue === 'string' && connectionValue !== 'ImplicitConnection'
-        ? tsLiteral(connectionValue) : undefined;
-    const folder = managed && typeof detail.connectionFolderKey === 'string' && detail.connectionFolderKey.length > 0
-        ? tsLiteral(detail.connectionFolderKey) : undefined;
-    const targetConnector = managed && typeof req.targetConnector === 'string'
-        && req.targetConnector !== 'uipath-uipath-http'
-        ? tsLiteral(req.targetConnector) : undefined;
-    const spec = opts([
-        ['url', emitVal(req.url ?? '', imp, inputNames)],
-        ['method', method !== 'GET' ? tsLiteral(method) : undefined],
-        ['headers', headersSrc],
-        ['query', querySrc],
-        ['body', bodySrc],
-        ['contentType', contentType],
-        ['managed', boolLit(managed)],
-        ['connection', connection],
-        ['folder', folder],
-        ['targetConnector', targetConnector],
-        ['timeout', timeout],
-        ['retryCount', retry],
-        ['branches', branchesSrc],
-    ]);
-    return `${imp.use('http')}(${spec})`;
-}
 /**
  * Split a connector `nodeType` (`uipath.connector.<key>.<action>`) into key +
  * action. Mirrors `core/connectors.ts`'s `splitConnectorNodeType`.
@@ -2715,9 +2644,9 @@ function outcomeIdsOfNode(node) {
  * The exits a node declares, read back off the EMITTED artifact rather than off
  * an authored spec — `inputs.schema.outcomes` for a base or quick-form human
  * task (the product draws one `outcome-<id>` handle per outcome on both, at
- * every version), `inputs.branches` plus `default` for an HTTP call. The
- * authoring-side twin is `declaredExits` in `core/step-ports.ts`; they answer
- * about different inputs, which is why this is not a call into it.
+ * every version), and a registered type's own `exits` over the spec its lift
+ * recovers (an HTTP call's `inputs.branches` plus `default`). The authoring-side
+ * twin is `stepExits` in `flow-step-exits.ts`.
  */
 function declaredExitsOfNode(node) {
     const inputs = (node.inputs ?? {});
@@ -2729,16 +2658,16 @@ function declaredExitsOfNode(node) {
             return undefined;
         return outcomes.map((o) => ({ value: String(o?.name ?? ''), port: `outcome-${o?.id ?? ''}` }));
     }
-    if (node.type === T.http || node.type === T.httpV2) {
-        const branches = (inputs.branches ?? []);
-        if (branches.length === 0)
-            return undefined;
-        return [
-            ...branches.map((b) => ({ value: String(b?.name ?? ''), port: `branch-${b?.name ?? ''}` })),
-            { value: 'default', port: 'default' },
-        ];
-    }
-    return undefined;
+    // A registered type that declares exits answers from its own spec, lifted off
+    // this node; one that declares none is not lifted at all (this runs per edge).
+    const impl = registeredImpl(node);
+    if (!impl?.exits)
+        return undefined;
+    const lifted = liftRegistered(node, impl);
+    const exits = lifted && impl.exits(lifted.spec);
+    if (!exits || !hasExits(exits))
+        return undefined;
+    return exits.map((e) => ({ value: e.value, port: e.port }));
 }
 /**
  * Split a switch case expression into `<discriminant> === <literal>`, the only

package/dist/flow-node-registry.js

@@ -8,13 +8,15 @@
  */
 import { NodeTypeRegistry } from './core/nodes/registry.js';
 import { hasBundledDefinition } from './flow-definitions.js';
+import { aiPatternsFlowFamily } from './nodes/ai-patterns/flow/family.js';
 import { dataFabricFlowFamily } from './nodes/data-fabric/flow/family.js';
 import { delayFlowFamily } from './nodes/delay/flow/family.js';
 import { documentFlowFamily } from './nodes/document/flow/family.js';
+import { httpFlowFamily } from './nodes/http/flow/family.js';
 import { mockFlowFamily } from './nodes/mock/flow/family.js';
 import { queueFlowFamily } from './nodes/queue/flow/family.js';
 import { scriptFlowFamily } from './nodes/script/flow/family.js';
 import { transformFlowFamily } from './nodes/transform/flow/family.js';
 /** The families, in no significant order. Adding one is the whole of registering it. */
-export const FLOW_NODE_FAMILIES = [dataFabricFlowFamily, delayFlowFamily, documentFlowFamily, mockFlowFamily, queueFlowFamily, scriptFlowFamily, transformFlowFamily];
+export const FLOW_NODE_FAMILIES = [aiPatternsFlowFamily, dataFabricFlowFamily, delayFlowFamily, documentFlowFamily, httpFlowFamily, mockFlowFamily, queueFlowFamily, scriptFlowFamily, transformFlowFamily];
 export const FLOW_NODE_TYPES = new NodeTypeRegistry('flow', FLOW_NODE_FAMILIES, { hasBundledDefinition });

package/dist/flow-node-type.d.ts

@@ -14,6 +14,7 @@ import type { VersionedNodeType } from './core/nodes/versioned.js';
 import type { NodeFamily, Placement } from './core/nodes/family.js';
 import type { DefinitionReference, NodeContribution } from './core/node-classes.js';
 import type { CheckOpts } from './check.js';
+import type { DeclaredExit, NoExits } from './core/step-ports.js';
 /**
  * What a Flow node type's `serialize` returns: the node's type-owned fields.
  *
@@ -81,6 +82,28 @@ export interface FlowSerializeContext {
      * pair) or must pick an id that is not taken; add entries through `bind`.
      */
     readonly bindings: ReadonlyMap<string, Readonly<Record<string, unknown>>>;
+    /**
+     * A symbolic `connection` or `folder` label resolved through the flow's
+     * bindings.json, as a connector step's is: a self-referential label throws the
+     * refusal check reports, and a value that cannot be a tenant id is warned about
+     * (`CONNECTION_STUB`). `where` names the site in both, e.g. `managed http "fetch"`.
+     */
+    resolveBinding(name: string, attribute: 'connection' | 'folder', where: string): string;
+    /**
+     * Hoist the Integration Service connection pair a definition's `model`
+     * references (`<bindings.NAME>` for its connection id and folder key), deduped
+     * against the flow's existing entries by name, resource key and attribute. An
+     * unresolved connection still gets its entries (no `default`), so the
+     * definition's references always close.
+     */
+    bindConnection(o: {
+        model: unknown;
+        connectorKey: string;
+        connectionId: string;
+        folderKey?: string;
+        /** The entries' `resourceKey`; defaults to `connectionId`. */
+        resourceKey?: string;
+    }): void;
 }
 /** What `deserialize` may ask of the decompiler, for one serialized node. */
 export interface FlowDeserializeContext {
@@ -146,6 +169,20 @@ export interface FlowCheckContext {
     } | undefined;
     /** The options `check` was called with (the connector-library views among them). */
     readonly options: CheckOpts;
+    /**
+     * Check a step's symbolic `connection` / `folder` labels against bindings.json,
+     * as a connector step's are, reporting `BINDING_SELF_NAME` / `BINDING_UNDECLARED`.
+     * Those codes are the pipeline's, shared by every family that binds a
+     * connection, so they belong to no family catalog. `use` names the connector
+     * the connection must belong to, for the cross-step connection-owner rule.
+     */
+    bindingLabels(where: string, labels: {
+        connection?: unknown;
+        folder?: unknown;
+    }, use?: {
+        id: string;
+        connector: string | undefined;
+    }): void;
 }
 /** What a family-level `check` may ask of the checker. */
 export interface FlowFamilyCheckContext {
@@ -199,6 +236,28 @@ export interface FlowNodeType<Spec> extends NodeType<Spec, FlowNodeContribution,
     readonly nodeModel?: 'definition' | 'omit';
     /** What `rawNode` reports for a raw node of this type. */
     readonly rawNode?: FlowRawNodeAdvice;
+    /**
+     * The runtime variable a failed node's envelope is published under, when it is
+     * not `error`. `err()` writes one shape for every family
+     * (`$vars.<step>.error.<field>`), and serialize rewrites a handler's reads to
+     * this variable.
+     *
+     * Measured on the product, one debug run per family (2026-09-10): six of the
+     * seven families probed publish it as `<step>.error`, which is what the
+     * definitions declare (`outputDefinition.error.var`). The exception is
+     * `core.action.http.v2`, whose `<step>.error` is the boolean `true` and whose
+     * envelope is in `<step>.output` (instance 430d43ad-4583-40c0-8f74-b49d2c4904e4).
+     */
+    readonly errorEnvelope?: string;
+    /**
+     * The exits the AUTHOR named on this step — an HTTP call's response branches,
+     * and the port each leaves on — or why it has none to route. What
+     * `.stepSwitch()` routes over, what an arm's `value` and a `.stepToList` port
+     * are checked against, and what decompile reads a fully wired node back as.
+     * Omitted: the type has no author-declared fan-out. The `error` port is never
+     * one of these (`.onError()` routes it).
+     */
+    exits?(spec: Spec): DeclaredExit[] | NoExits;
 }
 /** A Flow node type with several versions. */
 export type FlowVersionedNodeType<Spec> = VersionedNodeType<Spec, FlowNodeContribution, FlowContexts, FlowNodeType<Spec>>;

package/dist/flow-sdk.d.ts

@@ -18,9 +18,11 @@
  */
 export * from './core/expr.js';
 export * from './core/actions.js';
+export * from './nodes/ai-patterns/flow/index.js';
 export * from './nodes/data-fabric/flow/index.js';
 export * from './nodes/delay/flow/index.js';
 export * from './nodes/document/flow/index.js';
+export * from './nodes/http/flow/index.js';
 export * from './nodes/mock/flow/index.js';
 export * from './nodes/queue/flow/index.js';
 export * from './nodes/script/flow/index.js';

package/dist/flow-sdk.js

@@ -22,9 +22,11 @@
 export * from './core/expr.js';
 export * from './core/actions.js';
 // Node families' public surfaces (docs/NODE_TYPE_ARCHITECTURE_DESIGN.md §8).
+export * from './nodes/ai-patterns/flow/index.js';
 export * from './nodes/data-fabric/flow/index.js';
 export * from './nodes/delay/flow/index.js';
 export * from './nodes/document/flow/index.js';
+export * from './nodes/http/flow/index.js';
 export * from './nodes/mock/flow/index.js';
 export * from './nodes/queue/flow/index.js';
 export * from './nodes/script/flow/index.js';

package/dist/flow-step-exits.d.ts

@@ -0,0 +1,12 @@
+import { type DeclaredExit, type NoExits } from './core/step-ports.js';
+/**
+ * The author-declared exits of a step's spec: a registered type's own `exits`,
+ * at the version the step resolves to (its pin, else the type's choice; an
+ * unregistered pin falls back to that choice, as check's other rules do), and
+ * `declaredExits` for a kind not yet registered. `serialize` and `check` ask
+ * here, so they agree on what a port means.
+ */
+export declare function stepExits(spec: {
+    kind?: unknown;
+    inputs?: unknown;
+} | undefined, pinnedVersion?: string): DeclaredExit[] | NoExits;

package/dist/flow-step-exits.js

@@ -0,0 +1,30 @@
+/**
+ * The exits the author declared on a step — what `.stepSwitch()` routes over and
+ * a `.stepToList('<port>')` names — answered by the step's node type when its kind
+ * is registered (`FlowNodeType.exits`), else by `core/step-ports.ts` for a kind
+ * not yet ported. A module of its own so a test that swaps the registry
+ * (`vi.mock('./flow-node-registry.js')`) swaps what this asks too.
+ */
+import { resolveVersion } from './core/nodes/versioned.js';
+import { declaredExits } from './core/step-ports.js';
+import { FLOW_NODE_TYPES } from './flow-node-registry.js';
+/**
+ * The author-declared exits of a step's spec: a registered type's own `exits`,
+ * at the version the step resolves to (its pin, else the type's choice; an
+ * unregistered pin falls back to that choice, as check's other rules do), and
+ * `declaredExits` for a kind not yet registered. `serialize` and `check` ask
+ * here, so they agree on what a port means.
+ */
+export function stepExits(spec, pinnedVersion) {
+    const entry = typeof spec?.kind === 'string' ? FLOW_NODE_TYPES.byKind(spec.kind, spec) : undefined;
+    if (!entry)
+        return declaredExits(spec, pinnedVersion);
+    let impl;
+    try {
+        impl = resolveVersion(entry.type, spec, pinnedVersion, 'exits');
+    }
+    catch {
+        impl = resolveVersion(entry.type, spec, undefined, 'exits');
+    }
+    return impl.exits?.(spec) ?? declaredExits(spec, pinnedVersion);
+}

package/dist/nodes/ai-patterns/flow/factories.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The AI-pattern factories, `summarize()` and `batchTransform()`. Moved from
+ * core/actions.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the
+ * package entry re-exports them.
+ */
+import { type ActionSpec } from '../../../core/actions.js';
+import type { BatchTransformInputs, SummarizeInputs } from './spec.js';
+/**
+ * Summarize a document with citations — the platform's **Summarize** node.
+ *
+ * @remarks
+ * **The node type is `uipath.pattern.deep-rag`.** The canvas calls it
+ * *Summarize*, its properties panel is titled *Summarize Configuration*, and
+ * the wire type stays `deep-rag` — it is the same node, under the name the
+ * backend service contract uses (`ECS.DeepRag`). There is no
+ * `uipath.pattern.summarize`. (A same-named inline-agent TOOL,
+ * `uipath.agent.resource.tool.builtin.summarize`, is a different family.)
+ *
+ * The answer's fields are **PascalCase** — `content.Text`,
+ * `content.Citations[].{Ordinal, PageNumber, Source, Reference}`. Lowercase
+ * `content.text` resolves to nothing at run time.
+ *
+ * A local run cannot reach the service: it returns the baked
+ * fixture shape, and only a real platform run (`uip maestro flow debug
+ * --attachment <var>=<file>`) calls the model.
+ *
+ * @example
+ * **Summarize an attached contract, with citations**
+ * ```ts
+ * flow('SummarizeDemo')
+ *   .input({ documentFile: types.file })
+ *   .output({ summary: types.string, citations: types.array })
+ *   .step('summarizeContract', summarize({
+ *     attachment: out('start', 'documentFile'),
+ *     prompt: 'Write a 5-bullet executive summary covering scope, term and SLAs.',
+ *     returnCitations: true,
+ *   }))
+ *   .return({
+ *     summary:   out('summarizeContract', 'content.Text'),
+ *     citations: out('summarizeContract', 'content.Citations'),
+ *   })
+ * ```
+ *
+ * @param inputs - The document (`attachment`), the question to answer (`prompt`),
+ * and whether to return citations.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function summarize(inputs: SummarizeInputs): ActionSpec;
+/**
+ * Add AI-generated columns to a CSV — the platform's **Batch transform** node,
+ * `uipath.pattern.batch-transform` (service contract `ECS.BatchTransform`).
+ *
+ * @remarks
+ * The output is a **file handle for the enriched CSV**, not the rows:
+ * `{ ID, FullName, MimeType }` — the service writes a new
+ * `batch-transform-<uuid>.csv` and hands back its attachment. Note `ID`, two
+ * capitals: that is what the platform returns.
+ *
+ * Same dispatch story as {@link summarize} — dry-run fixture locally, a real
+ * model call only on a platform run.
+ *
+ * @example
+ * **Categorize each CSV row with two generated columns**
+ * ```ts
+ * flow('BatchTransformDemo')
+ *   .input({ csvFile: types.file })
+ *   .output({ result: types.file })
+ *   .step('categorizeRows', batchTransform({
+ *     attachment: out('start', 'csvFile'),
+ *     prompt: 'Classify each row by category and write a one-line summary.',
+ *     outputColumns: [
+ *       { name: 'Category', description: 'One of: Utility, Software, Travel, Other' },
+ *       { name: 'Summary',  description: 'Plain-English one-line summary of the row' },
+ *     ],
+ *   }))
+ *   .return({ result: out('categorizeRows') })
+ * ```
+ *
+ * @param inputs - The CSV (`attachment`), the instruction (`prompt`), and the
+ * `outputColumns` to add to each row.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function batchTransform(inputs: BatchTransformInputs): ActionSpec;

package/dist/nodes/ai-patterns/flow/factories.js

@@ -0,0 +1,86 @@
+/**
+ * The AI-pattern factories, `summarize()` and `batchTransform()`. Moved from
+ * core/actions.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the
+ * package entry re-exports them.
+ */
+import { builtinActionSpec } from '../../../core/actions.js';
+/**
+ * Summarize a document with citations — the platform's **Summarize** node.
+ *
+ * @remarks
+ * **The node type is `uipath.pattern.deep-rag`.** The canvas calls it
+ * *Summarize*, its properties panel is titled *Summarize Configuration*, and
+ * the wire type stays `deep-rag` — it is the same node, under the name the
+ * backend service contract uses (`ECS.DeepRag`). There is no
+ * `uipath.pattern.summarize`. (A same-named inline-agent TOOL,
+ * `uipath.agent.resource.tool.builtin.summarize`, is a different family.)
+ *
+ * The answer's fields are **PascalCase** — `content.Text`,
+ * `content.Citations[].{Ordinal, PageNumber, Source, Reference}`. Lowercase
+ * `content.text` resolves to nothing at run time.
+ *
+ * A local run cannot reach the service: it returns the baked
+ * fixture shape, and only a real platform run (`uip maestro flow debug
+ * --attachment <var>=<file>`) calls the model.
+ *
+ * @example
+ * **Summarize an attached contract, with citations**
+ * ```ts
+ * flow('SummarizeDemo')
+ *   .input({ documentFile: types.file })
+ *   .output({ summary: types.string, citations: types.array })
+ *   .step('summarizeContract', summarize({
+ *     attachment: out('start', 'documentFile'),
+ *     prompt: 'Write a 5-bullet executive summary covering scope, term and SLAs.',
+ *     returnCitations: true,
+ *   }))
+ *   .return({
+ *     summary:   out('summarizeContract', 'content.Text'),
+ *     citations: out('summarizeContract', 'content.Citations'),
+ *   })
+ * ```
+ *
+ * @param inputs - The document (`attachment`), the question to answer (`prompt`),
+ * and whether to return citations.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function summarize(inputs) {
+    return builtinActionSpec({ kind: 'summarize', inputs });
+}
+/**
+ * Add AI-generated columns to a CSV — the platform's **Batch transform** node,
+ * `uipath.pattern.batch-transform` (service contract `ECS.BatchTransform`).
+ *
+ * @remarks
+ * The output is a **file handle for the enriched CSV**, not the rows:
+ * `{ ID, FullName, MimeType }` — the service writes a new
+ * `batch-transform-<uuid>.csv` and hands back its attachment. Note `ID`, two
+ * capitals: that is what the platform returns.
+ *
+ * Same dispatch story as {@link summarize} — dry-run fixture locally, a real
+ * model call only on a platform run.
+ *
+ * @example
+ * **Categorize each CSV row with two generated columns**
+ * ```ts
+ * flow('BatchTransformDemo')
+ *   .input({ csvFile: types.file })
+ *   .output({ result: types.file })
+ *   .step('categorizeRows', batchTransform({
+ *     attachment: out('start', 'csvFile'),
+ *     prompt: 'Classify each row by category and write a one-line summary.',
+ *     outputColumns: [
+ *       { name: 'Category', description: 'One of: Utility, Software, Travel, Other' },
+ *       { name: 'Summary',  description: 'Plain-English one-line summary of the row' },
+ *     ],
+ *   }))
+ *   .return({ result: out('categorizeRows') })
+ * ```
+ *
+ * @param inputs - The CSV (`attachment`), the instruction (`prompt`), and the
+ * `outputColumns` to add to each row.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function batchTransform(inputs) {
+    return builtinActionSpec({ kind: 'batchTransform', inputs });
+}

package/dist/nodes/ai-patterns/flow/family.d.ts

@@ -0,0 +1,3 @@
+/** The AI-pattern node family, as flow-node-registry.ts lists it: `uipath.pattern.deep-rag` and `uipath.pattern.batch-transform`. */
+import type { FlowNodeFamily } from '../../../flow-node-type.js';
+export declare const aiPatternsFlowFamily: FlowNodeFamily;

package/dist/nodes/ai-patterns/flow/family.js

@@ -0,0 +1,8 @@
+import { aiPatternNodeTypes } from './node-type.js';
+export const aiPatternsFlowFamily = {
+    id: 'ai-patterns',
+    title: 'AI patterns',
+    types: aiPatternNodeTypes,
+    // No node-local rules: what an AI-pattern step could get wrong is the service's to say.
+    diagnostics: {},
+};

package/dist/nodes/ai-patterns/flow/index.d.ts

@@ -0,0 +1,3 @@
+/** The AI-pattern family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/ai-patterns/flow/index.js

@@ -0,0 +1,3 @@
+/** The AI-pattern family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/ai-patterns/flow/node-type.d.ts

@@ -0,0 +1,11 @@
+import type { FlowNodeType } from '../../../flow-node-type.js';
+import type { BatchTransformInputs, SummarizeInputs } from './spec.js';
+export type SummarizeSpec = {
+    kind: 'summarize';
+    inputs: SummarizeInputs;
+};
+export type BatchTransformSpec = {
+    kind: 'batchTransform';
+    inputs: BatchTransformInputs;
+};
+export declare const aiPatternNodeTypes: (FlowNodeType<SummarizeSpec> | FlowNodeType<BatchTransformSpec>)[];