@uipath/maestro-builder-sdk 6.23.0 → 6.24.0

package/dist/check.js

@@ -453,10 +453,6 @@ function checkFlow(built, ancestors, opts = {}) {
                 if (s.spec.kind === 'publishedFunction') {
                     checkPublishedFunction(s.name, s.spec.inputs, diags);
                 }
-                if (s.spec.kind === 'sendMessage' || s.spec.kind === 'waitForMessage'
-                    || s.spec.kind === 'conversationContext') {
-                    checkConversational(s.name, s.spec.kind, s.spec.inputs, diags);
-                }
                 if (s.spec.kind === 'createOutgoingCall' || s.spec.kind === 'endCall' || s.spec.kind === 'voiceAgent') {
                     checkVoice(s.name, s.spec.kind, s.spec.inputs, diags);
                 }
@@ -2283,54 +2279,6 @@ function checkVoice(step, kind, inputs, diags) {
         }
     }
 }
-/**
- * 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.
- */
-function checkConversational(step, kind, inputs, diags) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { 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);
-}
 /**
  * A published FUNCTION step (Phase 5B).
  *

package/dist/core/actions.d.ts

@@ -354,43 +354,6 @@ export interface HitlInputs {
      */
     document?: DocValidationInputs;
 }
-export interface SendMessageInputs {
-    /**
-     * The conversation to post into — from the conversation trigger
-     * (`out('start', 'conversationId')`) or a context read. Required.
-     */
-    conversationId: string | Expr;
-    /**
-     * The exchange (one user turn plus its answers) the message belongs to —
-     * `out('<waitStep>', 'conversationContext.latestExchangeId')`, or the
-     * trigger's exchange for the first answer. Required by the node's schema.
-     */
-    exchangeId: string | Expr;
-    /** What to say. Markdown — the node's only supported `mimeType`. Required. */
-    content: string | Expr;
-    /**
-     * Whether this message CLOSES the exchange. The platform's legacy default is
-     * to end it; pass `false` to keep the exchange open for another message.
-     */
-    endExchange?: boolean;
-}
-export interface WaitForMessageInputs {
-    /** The conversation to wait on. Required. */
-    conversationId: string | Expr;
-    /**
-     * How many past exchanges the returned context carries. 1–40 in the
-     * designer; the platform default is 20.
-     */
-    numExchanges?: number;
-}
-export interface ConversationContextInputs {
-    /** The conversation to read. Required. */
-    conversationId: string | Expr;
-    /**
-     * How many exchanges to return, 1–40. The platform default is 20.
-     */
-    exchangeLimit?: number;
-}
 /**
  * How a conversational agent gets its turn — the node's own
  * `conversationalAgentSettings` sub-object.
@@ -1753,18 +1716,6 @@ export interface FlowActionSpecs {
     publishedFunction: {
         inputs: PublishedFunctionInputs;
     };
-    /** The spec {@link sendMessage} builds. */
-    sendMessage: {
-        inputs: SendMessageInputs;
-    };
-    /** The spec {@link waitForMessage} builds. */
-    waitForMessage: {
-        inputs: WaitForMessageInputs;
-    };
-    /** The spec {@link conversationContext} builds. */
-    conversationContext: {
-        inputs: ConversationContextInputs;
-    };
     /** The spec {@link createOutgoingCall} builds. */
     createOutgoingCall: {
         inputs: CreateOutgoingCallInputs;
@@ -2068,57 +2019,6 @@ export declare function apiWorkflow(inputs: ApiWorkflowInputs): ActionSpec;
  * @returns An action spec to pass to `.step(...)`.
  */
 export declare function publishedFunction(inputs: PublishedFunctionInputs): ActionSpec;
-/**
- * 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;
 /**
  * Place an outgoing phone call
  * (`uipath.conversational.voice.create-outgoing-call`) and get back the

package/dist/core/actions.js

@@ -310,63 +310,6 @@ export function apiWorkflow(inputs) {
 export function publishedFunction(inputs) {
     return builtinActionSpec({ kind: 'publishedFunction', inputs });
 }
-/**
- * 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 });
-}
 /**
  * Place an outgoing phone call
  * (`uipath.conversational.voice.create-outgoing-call`) and get back the

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

@@ -32,11 +32,8 @@ export const TYPED_FACTORIES = {
     'uipath.agent.autonomous': { factory: 'inlineAgent()' },
     'uipath.agent.conversational': { factory: 'conversationalAgent()' },
     'uipath.agent.voice': { factory: 'voiceAgent()' },
-    'uipath.conversational.get-conversation-context': { factory: 'conversationContext()' },
-    'uipath.conversational.send-message': { factory: 'sendMessage()' },
     'uipath.conversational.voice.create-outgoing-call': { factory: 'createOutgoingCall()' },
     'uipath.conversational.voice.end-call': { factory: 'endCall()' },
-    'uipath.conversational.wait-for-message': { factory: 'waitForMessage()' },
     'uipath.human-in-the-loop': { factory: 'hitl()' },
     'uipath.human-in-the-loop.coded-action-app': {
         factory: "hitl({ variant: 'action-app' })",

package/dist/decompile.js

@@ -229,9 +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',
-    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',
@@ -659,47 +656,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
         case T.hitlActionApp:
         case T.hitlDocValidation:
             return emitHitl(node, imp, inputNames, graph);
-        case T.sendMessage:
-        case T.waitForMessage:
-        case T.conversationContext: {
-            // The fixed enum fields (`role`/`mimeType`/`from`) come from the
-            // definition's defaults, so nothing of them is recovered — only what an
-            // author could have written.
-            const i = (node.inputs ?? {});
-            const v = (x) => {
-                const raw = typeof x === 'string' ? x : String(x?.expression ?? x ?? '');
-                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames)
-                    : raw.startsWith('$vars.') ? emitBareExpr(raw, imp, inputNames)
-                        : tsLiteral(raw);
-            };
-            const num = (x) => {
-                if (x === undefined || x === null)
-                    return undefined;
-                const n = Number(x?.expression ?? x);
-                return Number.isFinite(n) ? String(n) : undefined;
-            };
-            const cid = ['conversationId', v(i.conversationId)];
-            if (node.type === T.sendMessage) {
-                return `${imp.use('sendMessage')}(${opts([
-                    cid,
-                    ['exchangeId', v(i.exchangeId)],
-                    ['content', v(i.content)],
-                    // The definition defaults `endExchange` to false; only a departure
-                    // from the default is something the author wrote.
-                    ['endExchange', i.endExchange === true ? 'true' : undefined],
-                ])})`;
-            }
-            if (node.type === T.waitForMessage) {
-                return `${imp.use('waitForMessage')}(${opts([
-                    cid,
-                    ['numExchanges', num(i.numExchanges) === '20' ? undefined : num(i.numExchanges)],
-                ])})`;
-            }
-            return `${imp.use('conversationContext')}(${opts([
-                cid,
-                ['exchangeLimit', num(i.exchangeLimit) === '20' ? undefined : num(i.exchangeLimit)],
-            ])})`;
-        }
         default:
             // A connector action node: `uipath.connector.<key>.<action>` (but NOT the
             // event nodes `uipath.connector.event.*` / `.trigger.*`, which are triggers).

package/dist/flow-node-registry.js

@@ -9,6 +9,7 @@
 import { NodeTypeRegistry } from './core/nodes/registry.js';
 import { hasBundledDefinition } from './flow-definitions.js';
 import { aiPatternsFlowFamily } from './nodes/ai-patterns/flow/family.js';
+import { conversationFlowFamily } from './nodes/conversation/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';
@@ -18,5 +19,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 = [aiPatternsFlowFamily, dataFabricFlowFamily, delayFlowFamily, documentFlowFamily, httpFlowFamily, mockFlowFamily, queueFlowFamily, scriptFlowFamily, transformFlowFamily];
+export const FLOW_NODE_FAMILIES = [aiPatternsFlowFamily, conversationFlowFamily, 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

@@ -19,6 +19,7 @@
 export * from './core/expr.js';
 export * from './core/actions.js';
 export * from './nodes/ai-patterns/flow/index.js';
+export * from './nodes/conversation/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

@@ -23,6 +23,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/conversation/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/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 {};