@uipath/maestro-builder-sdk 6.22.0 → 6.23.0

package/dist/core/actions.d.ts

@@ -536,62 +536,6 @@ export interface VoiceAgentInputs {
      */
     source?: string;
 }
-export interface SummarizeInputs {
-    /**
-     * The document to summarize — a whole **Flow Attachment** object
-     * (`{ ID, FullName, MimeType, Metadata }`), not a path, id or URL.
-     *
-     * In practice that is a `file`-typed flow input:
-     *
-     * ```ts
-     * flow('SummarizeDemo')
-     *   .input({ documentFile: types.file })
-     *   .step('summarizeContract', summarize({ attachment: input('documentFile'), … }))
-     * ```
-     *
-     * `out('start', 'documentFile')` is the same value written the way the CANVAS
-     * writes it (`$vars.start.output.documentFile`, resolved through the input's
-     * `triggerNodeId` binding). Both forms run — measured on the real service —
-     * so prefer whichever the task asks for; `out('start', …)` is what a
-     * designer-made flow looks like.
-     *
-     * The service reads the file's CONTENT, and refuses one it cannot treat as a
-     * document: a PDF summarizes, a plain `.txt` comes back
-     * `[460005] … "No valid files to use for Summarization."`
-     */
-    attachment: Expr;
-    /** What the summary should cover, e.g. `'Write a 5-bullet executive summary…'`. */
-    prompt: string | Expr;
-    /**
-     * Ask the service for per-claim citations. Each is
-     * `{ Ordinal, PageNumber, Source, Reference }` and lands in
-     * `out('<step>', 'content.Citations')`. Defaults to `false`.
-     */
-    returnCitations?: boolean;
-}
-/** One column Batch Transform appends to the CSV. */
-export interface OutputColumn {
-    /** The new column's header, e.g. `'Category'`. */
-    name: string;
-    /** What the model should put in it, e.g. `'One of: Utility, Software, Travel, Other'`. */
-    description: string;
-}
-export interface BatchTransformInputs {
-    /**
-     * The CSV to enrich — a whole **Flow Attachment** object, same shape and same
-     * two ways of referencing it as {@link SummarizeInputs.attachment}.
-     */
-    attachment: Expr;
-    /** How to process each row, e.g. `'Classify each row and write a one-line summary.'`. */
-    prompt: string | Expr;
-    /**
-     * The columns to add, in order. The node's own field name — an array of
-     * `{ name, description }`, one per new column.
-     */
-    outputColumns: OutputColumn[];
-    /** Let the model use web search while transforming. Defaults to `false`. */
-    enableWebSearchGrounding?: boolean;
-}
 /**
  * Split an extractor's node type into the two GUIDs its tail packs.
  *
@@ -1849,14 +1793,6 @@ export interface FlowActionSpecs {
     inlineAgent: {
         inputs: InlineAgentInputs;
     };
-    /** The spec {@link summarize} builds. */
-    summarize: {
-        inputs: SummarizeInputs;
-    };
-    /** The spec {@link batchTransform} builds. */
-    batchTransform: {
-        inputs: BatchTransformInputs;
-    };
     /** The spec {@link ixpExtract} builds. */
     ixpExtract: {
         inputs: IxpExtractInputs;
@@ -1972,82 +1908,6 @@ export declare function builtinTriggerSpec<S extends object>(spec: S): S;
  * @example example-eval/GallerySubmission.flow.ts
  */
 export declare function hitl(inputs: HitlInputs): ActionSpec;
-/**
- * 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;
 /**
  * Extract fields from a document with a published IxP project — the platform's
  * **Extract** node (`uipath.ixp.*`, service contract `IXP.Extraction`).

package/dist/core/actions.js

@@ -142,86 +142,6 @@ export function builtinTriggerSpec(spec) {
 export function hitl(inputs) {
     return builtinActionSpec({ kind: 'hitl', inputs });
 }
-/**
- * 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 });
-}
 /**
  * Extract fields from a document with a published IxP project — the platform's
  * **Extract** node (`uipath.ixp.*`, service contract `IXP.Extraction`).

package/dist/core/typed-raw-node.js

@@ -45,8 +45,6 @@ export const TYPED_FACTORIES = {
         factory: "hitl({ variant: 'document-validation' })",
     },
     'uipath.human-in-the-loop.quick-form': { factory: "hitl({ variant: 'quick-form' })" },
-    'uipath.pattern.batch-transform': { factory: 'batchTransform()' },
-    'uipath.pattern.deep-rag': { factory: 'summarize()' },
 };
 /**
  * A reminder, as a `warning`, that a `rawNode` stands in for a typed factory,

package/dist/decompile.js

@@ -229,8 +229,6 @@ 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',
@@ -637,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: {
@@ -662,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: {

package/dist/flow-node-registry.js

@@ -8,6 +8,7 @@
  */
 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';
@@ -17,5 +18,5 @@ 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, httpFlowFamily, 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-sdk.d.ts

@@ -18,6 +18,7 @@
  */
 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';

package/dist/flow-sdk.js

@@ -22,6 +22,7 @@
 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';

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>)[];

package/dist/nodes/ai-patterns/flow/node-type.js

@@ -0,0 +1,106 @@
+/**
+ * The two AI-pattern node types: `uipath.pattern.deep-rag` (Summarize) and
+ * `uipath.pattern.batch-transform`, each bundled at 1.0. Moved from
+ * serialize.ts / decompile.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md;
+ * serialized output and printed source unchanged.
+ */
+import { Expr } from '../../../core/expr.js';
+/** A value as the author wrote it: an expression back to an Expr, a literal string as itself, any other JSON as is. */
+function lifted(raw, ctx) {
+    const text = Array.isArray(raw) ? undefined : ctx.sourceText(raw);
+    if (text === undefined)
+        return raw;
+    return text.startsWith('=js:') ? ctx.expr(text) : text;
+}
+/** A spec value as source: an Expr as the helper an author writes, `undefined` as itself, anything else as data. */
+function printed(v, ctx) {
+    if (v === undefined)
+        return 'undefined';
+    return v instanceof Expr ? ctx.value(v) : ctx.json(v);
+}
+// Neither node carries a node-level `model`: both are `bpmn:ServiceTask`s whose
+// `serviceType` the platform resolves from `definitions[]`, and every deployed
+// instance of either carries none — v1's own structural checker fails a flow
+// that has one. The resource model stays on the DEFINITION only, as it does for
+// the published families. Per call (`model: 'omit'`), so a `rawNode` of either
+// type keeps what it has always written.
+const summarizeType = {
+    kind: 'summarize', typeName: 'uipath.pattern.deep-rag', version: '1.0', factory: 'summarize', definition: 'bundled',
+    rawNode: { factory: 'summarize()' },
+    // Each field is written under the NODE's own name, so the surface and the
+    // emitted file read alike.
+    serialize: ({ inputs }, ctx) => ({
+        model: 'omit',
+        inputs: {
+            attachment: ctx.render(inputs.attachment),
+            prompt: ctx.render(inputs.prompt),
+            returnCitations: inputs.returnCitations ?? false,
+        },
+        port: 'output',
+    }),
+    deserialize: (node, ctx) => {
+        const i = (node.inputs ?? {});
+        return {
+            kind: 'summarize',
+            inputs: {
+                attachment: lifted(i.attachment, ctx),
+                prompt: lifted(i.prompt, ctx),
+                // The flag defaults to false in the emitted node; only `true` was authored.
+                ...(ctx.plainValue(i.returnCitations) === true ? { returnCitations: true } : {}),
+            },
+        };
+    },
+    print: ({ inputs }, ctx) => ({
+        factory: 'summarize',
+        options: [
+            ['attachment', printed(inputs.attachment, ctx)],
+            ['prompt', printed(inputs.prompt, ctx)],
+            ['returnCitations', inputs.returnCitations === true ? 'true' : undefined],
+        ],
+    }),
+    // Deliberately none: references in the prompt, the attachment and the columns are not checked.
+    expressions: () => [],
+    output: () => ({ kind: 'opaque' }),
+};
+const batchTransformType = {
+    kind: 'batchTransform', typeName: 'uipath.pattern.batch-transform', version: '1.0', factory: 'batchTransform',
+    definition: 'bundled',
+    rawNode: { factory: 'batchTransform()' },
+    serialize: ({ inputs }, ctx) => ({
+        model: 'omit',
+        inputs: {
+            attachment: ctx.render(inputs.attachment),
+            prompt: ctx.render(inputs.prompt),
+            enableWebSearchGrounding: inputs.enableWebSearchGrounding ?? false,
+            // Rendered per column, so an expression in a description renders like every other input.
+            outputColumns: inputs.outputColumns.map((c) => Object.fromEntries(Object.entries(c).map(([k, v]) => [k, ctx.render(v)]))),
+        },
+        port: 'output',
+    }),
+    deserialize: (node, ctx) => {
+        const i = (node.inputs ?? {});
+        const cols = Array.isArray(i.outputColumns) ? i.outputColumns : [];
+        return {
+            kind: 'batchTransform',
+            inputs: {
+                attachment: lifted(i.attachment, ctx),
+                prompt: lifted(i.prompt, ctx),
+                outputColumns: cols.map((c) => ({ name: lifted(c.name, ctx), description: lifted(c.description, ctx) })),
+                ...(ctx.plainValue(i.enableWebSearchGrounding) === true ? { enableWebSearchGrounding: true } : {}),
+            },
+        };
+    },
+    print: ({ inputs }, ctx) => ({
+        factory: 'batchTransform',
+        options: [
+            ['attachment', printed(inputs.attachment, ctx)],
+            ['prompt', printed(inputs.prompt, ctx)],
+            ['outputColumns', `[${inputs.outputColumns.map((c) => `{ name: ${printed(c.name, ctx)}, description: ${printed(c.description, ctx)} }`).join(', ')}]`],
+            ['enableWebSearchGrounding', inputs.enableWebSearchGrounding === true ? 'true' : undefined],
+        ],
+    }),
+    // Deliberately none, as for Summarize.
+    expressions: () => [],
+    output: () => ({ kind: 'opaque' }),
+};
+export const aiPatternNodeTypes = [summarizeType, batchTransformType];