@uipath/maestro-builder-sdk 6.23.0 → 6.24.0

package/dist/nodes/conversation/flow/node-type.js

@@ -0,0 +1,117 @@
+/**
+ * The three conversational node types: `uipath.conversational.send-message`
+ * (1.0, 1.1), `.wait-for-message` (1.0, 1.1) and `.get-conversation-context`
+ * (1.0). Moved from serialize.ts / check.ts / decompile.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; serialized output, printed source,
+ * codes and messages unchanged.
+ */
+import { Expr, toExpr } from '../../../core/expr.js';
+import { jsonClone } from '../../../core/json-file.js';
+import { checkConversational } from './check.js';
+/**
+ * The definition's `inputDefaults`, which supply the fixed fields the platform's
+ * schema requires (`role: 'assistant'` and `mimeType: 'text/markdown'` on send,
+ * `from: 'User'` on wait) — the author never writes a value the enum only allows
+ * one of. Always the 1.0 definition's, whatever version is emitted: that is what
+ * the pipeline wrote before the port (its `defByType` holds the first bundled
+ * copy), so a 1.1 step still carries 1.0's `endExchange` / `numExchanges` keys.
+ */
+function defaults(ctx, typeName) {
+    return jsonClone(ctx.definition(typeName, '1.0')?.inputDefaults ?? {});
+}
+/** A value rendered as the file stores it; a bare literal is wrapped first, as the pipeline did. */
+const rendered = (ctx, v) => ctx.render(toExpr(v));
+/**
+ * A serialized value as the author wrote it. Decompile's own reading: the text of
+ * a string, or of an envelope's `expression`; `=js:` and a bare `$vars.` path are
+ * references, anything else a literal string.
+ */
+function lifted(x, ctx) {
+    const raw = typeof x === 'string' ? x : String(x?.expression ?? x ?? '');
+    if (raw.startsWith('=js:'))
+        return ctx.expr(raw);
+    if (raw.startsWith('$vars.'))
+        return ctx.expr(`=js:${raw}`);
+    return raw;
+}
+/** A number, or undefined for an absent or non-finite one. */
+function liftedNumber(x) {
+    if (x === undefined || x === null)
+        return undefined;
+    const n = Number(x?.expression ?? x);
+    return Number.isFinite(n) ? n : undefined;
+}
+const printed = (v, ctx) => (v instanceof Expr ? ctx.value(v) : ctx.string(String(v)));
+function conversationAt(kind, typeName, version) {
+    return {
+        kind, typeName, version, factory: kind, definition: 'bundled',
+        rawNode: { factory: `${kind}()` },
+        serialize: (spec, ctx) => {
+            const i = spec.inputs;
+            const base = { ...defaults(ctx, typeName), conversationId: rendered(ctx, i.conversationId) };
+            const inputs = kind === 'sendMessage'
+                ? {
+                    ...base,
+                    exchangeId: rendered(ctx, i.exchangeId),
+                    content: rendered(ctx, i.content),
+                    ...(i.endExchange !== undefined ? { endExchange: i.endExchange } : {}),
+                }
+                : kind === 'waitForMessage'
+                    ? { ...base, ...(i.numExchanges !== undefined ? { numExchanges: i.numExchanges } : {}) }
+                    : { ...base, ...(i.exchangeLimit !== undefined ? { exchangeLimit: i.exchangeLimit } : {}) };
+            // The service model stays on the DEFINITION only: these are
+            // `bpmn:ServiceTask` / `bpmn:IntermediateCatchEvent` nodes whose
+            // serviceType the platform resolves from `definitions[]`.
+            return { model: 'omit', inputs, port: 'output' };
+        },
+        // The fixed enum fields come from the definition's defaults, so nothing of
+        // them is recovered — only what an author could have written.
+        deserialize: (node, ctx) => {
+            const i = (node.inputs ?? {});
+            const conversationId = lifted(i.conversationId, ctx);
+            if (kind === 'sendMessage') {
+                return {
+                    kind,
+                    inputs: {
+                        conversationId,
+                        exchangeId: lifted(i.exchangeId, ctx),
+                        content: lifted(i.content, ctx),
+                        // The definition defaults `endExchange` to false; only a departure was authored.
+                        ...(i.endExchange === true ? { endExchange: true } : {}),
+                    },
+                };
+            }
+            const field = kind === 'waitForMessage' ? 'numExchanges' : 'exchangeLimit';
+            const n = liftedNumber(i[field]);
+            return { kind, inputs: { conversationId, ...(n !== undefined && n !== 20 ? { [field]: n } : {}) } };
+        },
+        print: (spec, ctx) => {
+            const i = spec.inputs;
+            const cid = ['conversationId', printed(i.conversationId, ctx)];
+            if (kind === 'sendMessage') {
+                return {
+                    factory: kind,
+                    options: [cid, ['exchangeId', printed(i.exchangeId, ctx)], ['content', printed(i.content, ctx)],
+                        ['endExchange', i.endExchange === true ? 'true' : undefined]],
+                };
+            }
+            const field = kind === 'waitForMessage' ? 'numExchanges' : 'exchangeLimit';
+            return { factory: kind, options: [cid, [field, i[field] !== undefined ? ctx.json(i[field]) : undefined]] };
+        },
+        check: (spec, ctx) => checkConversational(kind, spec.inputs, ctx),
+        // check collected no expressions for a conversational step before the port; unchanged by it.
+        expressions: () => [],
+        output: () => ({ kind: 'opaque' }),
+    };
+}
+function conversationType(kind, typeName, versions) {
+    return {
+        kind, typeName, factory: kind, defaultVersion: '1.0',
+        versions: Object.fromEntries(versions.map((v) => [v, conversationAt(kind, typeName, v)])),
+    };
+}
+export const conversationNodeTypes = [
+    conversationType('sendMessage', 'uipath.conversational.send-message', ['1.0', '1.1']),
+    conversationType('waitForMessage', 'uipath.conversational.wait-for-message', ['1.0', '1.1']),
+    conversationType('conversationContext', 'uipath.conversational.get-conversation-context', ['1.0']),
+];

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

@@ -0,0 +1,60 @@
+/**
+ * The conversation family's authoring types (`uipath.conversational.send-message`,
+ * `.wait-for-message`, `.get-conversation-context`), 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 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;
+}
+declare module '../../../core/actions.js' {
+    interface FlowActionSpecs {
+        /** The spec {@link sendMessage} builds. */
+        sendMessage: {
+            inputs: SendMessageInputs;
+        };
+        /** The spec {@link waitForMessage} builds. */
+        waitForMessage: {
+            inputs: WaitForMessageInputs;
+        };
+        /** The spec {@link conversationContext} builds. */
+        conversationContext: {
+            inputs: ConversationContextInputs;
+        };
+    }
+}

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

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

package/dist/serialize.js

@@ -90,9 +90,6 @@ const NODE_TYPE = {
     scheduledTrigger: 'core.trigger.scheduled',
     formTrigger: 'core.trigger.form',
     conversationTrigger: 'core.trigger.conversation',
-    sendMessage: 'uipath.conversational.send-message',
-    waitForMessage: 'uipath.conversational.wait-for-message',
-    conversationContext: 'uipath.conversational.get-conversation-context',
     voiceTrigger: 'core.trigger.voice',
     voiceAgent: 'uipath.agent.voice',
     conversationalAgent: 'uipath.agent.conversational',
@@ -3635,9 +3632,6 @@ export function bundledActionNodeType(spec) {
         case 'hitl': return hitlNodeType(spec.inputs);
         case 'inlineAgent': return INLINE_AGENT_TYPE;
         case 'subflow':
-        case 'sendMessage':
-        case 'waitForMessage':
-        case 'conversationContext':
         case 'createOutgoingCall':
         case 'endCall':
         case 'voiceAgent':
@@ -6020,48 +6014,6 @@ export function serialize(built, opts = {}) {
                 addEdge(scope, t, id);
             return [{ node: id, port: successPort(NODE_TYPE.voiceAgent) }];
         }
-        if (spec.kind === 'sendMessage' || spec.kind === 'waitForMessage' || spec.kind === 'conversationContext') {
-            // One emit path for the three CONVERSATIONAL steps: they differ in their
-            // definition and in which fields they carry. Each field is written under
-            // the node's own name, and the definition's `inputDefaults` supply the
-            // fixed ones the platform's schema requires (`role: 'assistant'` and
-            // `mimeType: 'text/markdown'` on send, `from: 'User'` on wait) — the
-            // author never writes a value the enum only allows one of.
-            const type = spec.kind === 'sendMessage' ? NODE_TYPE.sendMessage
-                : spec.kind === 'waitForMessage' ? NODE_TYPE.waitForMessage
-                    : NODE_TYPE.conversationContext;
-            const id = stepUid(scope, step.name);
-            const node = makeNode(type, id, step.name, { parentId, requestedVersion: step.options?.version });
-            // The service model stays on the DEFINITION only, as it does for the AI
-            // patterns and the published families: these are `bpmn:ServiceTask` /
-            // `bpmn:IntermediateCatchEvent` nodes whose serviceType the platform
-            // resolves from `definitions[]`.
-            delete node.model;
-            const defaults = jsonClone(defByType.get(type)?.inputDefaults ?? {});
-            node.inputs = spec.kind === 'sendMessage'
-                ? {
-                    ...defaults,
-                    conversationId: renderValue(toExpr(spec.inputs.conversationId), scope.rename),
-                    exchangeId: renderValue(toExpr(spec.inputs.exchangeId), scope.rename),
-                    content: renderValue(toExpr(spec.inputs.content), scope.rename),
-                    ...(spec.inputs.endExchange !== undefined ? { endExchange: spec.inputs.endExchange } : {}),
-                }
-                : spec.kind === 'waitForMessage'
-                    ? {
-                        ...defaults,
-                        conversationId: renderValue(toExpr(spec.inputs.conversationId), scope.rename),
-                        ...(spec.inputs.numExchanges !== undefined ? { numExchanges: spec.inputs.numExchanges } : {}),
-                    }
-                    : {
-                        ...defaults,
-                        conversationId: renderValue(toExpr(spec.inputs.conversationId), scope.rename),
-                        ...(spec.inputs.exchangeLimit !== undefined ? { exchangeLimit: spec.inputs.exchangeLimit } : {}),
-                    };
-            scope.nodes.push(node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(type) }];
-        }
         if (spec.kind === 'ixpExtract') {
             const s = spec.inputs;
             const def = perCallDefinition(spec); // ixpExtractDef: throws on an unparseable project

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.23.0",
+  "version": "6.24.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "4e81a94f4009b646e93353cd0043286f725a4507"
+  "gitref": "a3e8314b01bff6cf76316765840e31bd2e3860e5"
 }