@uipath/maestro-builder-sdk 6.22.0 → 6.24.0

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

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

@@ -0,0 +1,75 @@
+/**
+ * The AI-pattern family's authoring types (`uipath.pattern.deep-rag`,
+ * `uipath.pattern.batch-transform`), and their kinds' entries in
+ * `FlowActionSpecs`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md.
+ */
+import type { Expr } from '../../../core/expr.js';
+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;
+}
+declare module '../../../core/actions.js' {
+    interface FlowActionSpecs {
+        /** The spec {@link summarize} builds. */
+        summarize: {
+            inputs: SummarizeInputs;
+        };
+        /** The spec {@link batchTransform} builds. */
+        batchTransform: {
+            inputs: BatchTransformInputs;
+        };
+    }
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/nodes/conversation/flow/check.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The conversation family's rules. Moved from check.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; codes and messages unchanged.
+ */
+import type { DiagnosticCatalog } from '../../../core/nodes/family.js';
+import type { FlowCheckContext } from '../../../flow-node-type.js';
+export declare const CONVERSATION_DIAGNOSTICS: DiagnosticCatalog;
+/**
+ * A conversational step (Phase 5C): send-message, wait-for-message, or
+ * get-conversation-context.
+ *
+ * Everything here is decidable offline and invisible later: the node's own
+ * schema requires `conversationId` (and `exchangeId`/`content` on send), and
+ * the two numeric limits are range-checked by the designer but silently
+ * clamped at run time.
+ */
+export declare function checkConversational(kind: 'sendMessage' | 'waitForMessage' | 'conversationContext', inputs: Record<string, unknown> | undefined, ctx: FlowCheckContext): void;

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

@@ -0,0 +1,54 @@
+import { Expr } from '../../../core/expr.js';
+export const CONVERSATION_DIAGNOSTICS = {
+    CONVERSATION_NO_ID: { severity: 'error', summary: 'a conversational step with no conversationId' },
+    SEND_MESSAGE_NO_EXCHANGE: { severity: 'error', summary: 'sendMessage with no exchangeId' },
+    SEND_MESSAGE_NO_CONTENT: { severity: 'error', summary: 'sendMessage with no content' },
+    CONVERSATION_RANGE: { severity: 'error', summary: 'a history limit outside 1–40' },
+};
+/**
+ * A conversational step (Phase 5C): send-message, wait-for-message, or
+ * get-conversation-context.
+ *
+ * Everything here is decidable offline and invisible later: the node's own
+ * schema requires `conversationId` (and `exchangeId`/`content` on send), and
+ * the two numeric limits are range-checked by the designer but silently
+ * clamped at run time.
+ */
+export function checkConversational(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() === '');
+    const label = kind === 'sendMessage' ? 'sendMessage'
+        : kind === 'waitForMessage' ? 'waitForMessage' : 'conversationContext';
+    if (blank(inputs?.conversationId)) {
+        at('CONVERSATION_NO_ID', `${label} step "${step}" has no \`conversationId\`, which the node's schema requires — every `
+            + `conversational step is keyed by the conversation it belongs to. The conversation trigger publishes `
+            + `it as out('start', 'conversationId').`, `conversationId: out('start', 'conversationId')`);
+    }
+    if (kind === 'sendMessage') {
+        if (blank(inputs?.exchangeId)) {
+            at('SEND_MESSAGE_NO_EXCHANGE', `sendMessage step "${step}" has no \`exchangeId\` — the node's schema requires it, because a message `
+                + `belongs to one exchange (a user turn and its answers). A wait step publishes it as `
+                + `out('<waitStep>', 'conversationContext.latestExchangeId').`, `exchangeId: out('<waitStep>', 'conversationContext.latestExchangeId')`);
+        }
+        if (blank(inputs?.content)) {
+            at('SEND_MESSAGE_NO_CONTENT', `sendMessage step "${step}" has no \`content\` — the node's schema requires a non-empty message `
+                + `(Markdown), and an empty one posts a blank turn into the conversation.`, `content: 'Looking into it.'`);
+        }
+    }
+    const rangeCheck = (field, max) => {
+        const raw = inputs?.[field];
+        if (raw === undefined || raw instanceof Expr)
+            return;
+        const n = Number(raw);
+        if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1 || n > max) {
+            at('CONVERSATION_RANGE', `${label} step "${step}"'s \`${field}\` is ${JSON.stringify(raw)}. The node accepts a whole number from `
+                + `1 to ${max} (the platform default is 20); anything else is clamped at run time, so the flow reads `
+                + `a different amount of history than it says.`, `${field}: 20`);
+        }
+    };
+    if (kind === 'waitForMessage')
+        rangeCheck('numExchanges', 40);
+    if (kind === 'conversationContext')
+        rangeCheck('exchangeLimit', 40);
+}

package/dist/nodes/conversation/flow/factories.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The conversation factories, `sendMessage()`, `waitForMessage()` and
+ * `conversationContext()`. 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 { ConversationContextInputs, SendMessageInputs, WaitForMessageInputs } from './spec.js';
+/**
+ * Post an assistant message into a live conversation
+ * (`uipath.conversational.send-message`).
+ *
+ * ```ts
+ * .step('answer', sendMessage({
+ *   conversationId: out('start', 'conversationId'),
+ *   exchangeId: out('listen', 'conversationContext.latestExchangeId'),
+ *   content: 'Your order ships tomorrow.',
+ * }))
+ * ```
+ *
+ * The message is Markdown (`text/markdown` is the node's only supported type)
+ * and the role is always `assistant` — a flow speaks as the assistant.
+ *
+ * @param inputs - The conversation, the exchange, and what to say.
+ * @returns An action spec to pass to `.step(...)`.
+ */
+export declare function sendMessage(inputs: SendMessageInputs): ActionSpec;
+/**
+ * PAUSE until the person sends their next message
+ * (`uipath.conversational.wait-for-message`) — a catch event, like
+ * `waitForEvent`, so the flow suspends rather than polling.
+ *
+ * ```ts
+ * .step('listen', waitForMessage({ conversationId: out('start', 'conversationId') }))
+ * ```
+ *
+ * It resumes with the conversation context:
+ * `out('listen', 'conversationContext.messages')` is the transcript and
+ * `…conversationContext.latestExchangeId` is the turn to answer.
+ *
+ * @param inputs - The conversation to wait on, and how much history to return.
+ * @returns An action spec to pass to `.step(...)`.
+ */
+export declare function waitForMessage(inputs: WaitForMessageInputs): ActionSpec;
+/**
+ * READ a conversation's transcript so far without waiting
+ * (`uipath.conversational.get-conversation-context`) — the shape a
+ * conversational agent takes as its turn context.
+ *
+ * ```ts
+ * .step('history', conversationContext({
+ *   conversationId: out('start', 'conversationId'), exchangeLimit: 10,
+ * }))
+ * ```
+ *
+ * @param inputs - The conversation to read, and how many exchanges to return.
+ * @returns An action spec to pass to `.step(...)`.
+ */
+export declare function conversationContext(inputs: ConversationContextInputs): ActionSpec;

package/dist/nodes/conversation/flow/factories.js

@@ -0,0 +1,63 @@
+/**
+ * The conversation factories, `sendMessage()`, `waitForMessage()` and
+ * `conversationContext()`. 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';
+/**
+ * Post an assistant message into a live conversation
+ * (`uipath.conversational.send-message`).
+ *
+ * ```ts
+ * .step('answer', sendMessage({
+ *   conversationId: out('start', 'conversationId'),
+ *   exchangeId: out('listen', 'conversationContext.latestExchangeId'),
+ *   content: 'Your order ships tomorrow.',
+ * }))
+ * ```
+ *
+ * The message is Markdown (`text/markdown` is the node's only supported type)
+ * and the role is always `assistant` — a flow speaks as the assistant.
+ *
+ * @param inputs - The conversation, the exchange, and what to say.
+ * @returns An action spec to pass to `.step(...)`.
+ */
+export function sendMessage(inputs) {
+    return builtinActionSpec({ kind: 'sendMessage', inputs });
+}
+/**
+ * PAUSE until the person sends their next message
+ * (`uipath.conversational.wait-for-message`) — a catch event, like
+ * `waitForEvent`, so the flow suspends rather than polling.
+ *
+ * ```ts
+ * .step('listen', waitForMessage({ conversationId: out('start', 'conversationId') }))
+ * ```
+ *
+ * It resumes with the conversation context:
+ * `out('listen', 'conversationContext.messages')` is the transcript and
+ * `…conversationContext.latestExchangeId` is the turn to answer.
+ *
+ * @param inputs - The conversation to wait on, and how much history to return.
+ * @returns An action spec to pass to `.step(...)`.
+ */
+export function waitForMessage(inputs) {
+    return builtinActionSpec({ kind: 'waitForMessage', inputs });
+}
+/**
+ * READ a conversation's transcript so far without waiting
+ * (`uipath.conversational.get-conversation-context`) — the shape a
+ * conversational agent takes as its turn context.
+ *
+ * ```ts
+ * .step('history', conversationContext({
+ *   conversationId: out('start', 'conversationId'), exchangeLimit: 10,
+ * }))
+ * ```
+ *
+ * @param inputs - The conversation to read, and how many exchanges to return.
+ * @returns An action spec to pass to `.step(...)`.
+ */
+export function conversationContext(inputs) {
+    return builtinActionSpec({ kind: 'conversationContext', inputs });
+}

package/dist/nodes/conversation/flow/family.d.ts

@@ -0,0 +1,3 @@
+/** The conversation node family, as flow-node-registry.ts lists it: the three `uipath.conversational.*` steps. */
+import type { FlowNodeFamily } from '../../../flow-node-type.js';
+export declare const conversationFlowFamily: FlowNodeFamily;

package/dist/nodes/conversation/flow/family.js

@@ -0,0 +1,8 @@
+import { CONVERSATION_DIAGNOSTICS } from './check.js';
+import { conversationNodeTypes } from './node-type.js';
+export const conversationFlowFamily = {
+    id: 'conversation',
+    title: 'Conversation',
+    types: conversationNodeTypes,
+    diagnostics: CONVERSATION_DIAGNOSTICS,
+};

package/dist/nodes/conversation/flow/index.d.ts

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

package/dist/nodes/conversation/flow/index.js

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

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

@@ -0,0 +1,14 @@
+import type { FlowVersionedNodeType } from '../../../flow-node-type.js';
+import type { ConversationContextInputs, SendMessageInputs, WaitForMessageInputs } from './spec.js';
+type Spec = {
+    kind: 'sendMessage';
+    inputs: SendMessageInputs;
+} | {
+    kind: 'waitForMessage';
+    inputs: WaitForMessageInputs;
+} | {
+    kind: 'conversationContext';
+    inputs: ConversationContextInputs;
+};
+export declare const conversationNodeTypes: FlowVersionedNodeType<Spec>[];
+export {};