@uipath/maestro-builder-sdk 6.15.6 → 6.16.1

package/dist/serialize.js

@@ -45,7 +45,7 @@ import { declaredScriptShape, inferScriptShape } from './core/script-return.js';
 import { migrateToSchemaVersion } from './migrate.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from './schema-version.js';
-import { planFlowGlobals } from './flow-variables.js';
+import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
 import { prepareCommand } from './core/cli-spelling.js';
 import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -1002,8 +1002,10 @@ const TOOL_RESOURCE_TYPE = {
  *    and the file is the one `uip agent refresh` itself derives from it.
  *  * `mcp`, `a2a` — need the server's `availableTools` and the remote agent's
  *    card, which are tenant reads.
- *  * `builtin`, `httpRequest` — need a `properties.toolType` that maps
- *    one-to-one for `batchtransform` alone; a wrong one selects a different tool.
+ *  * `builtin` — has its own writer, {@link builtinToolResourceJson}: its
+ *    `toolType` is a fixed per-tool constant, so the file is derivable offline.
+ *  * `httpRequest` — its `http-request` toolType carries no request config in
+ *    the file, while the node carries all of it; not measured, so not written.
  */
 function toolResourceJson(tr, spec) {
     const common = {
@@ -1047,6 +1049,153 @@ function toolResourceJson(tr, spec) {
     }
     return undefined;
 }
+/**
+ * The `properties.toolType` each platform built-in tool carries in the agent
+ * project. Neither the node type nor the label: `analyzefiles` is the
+ * designer's "Analyze Files" and its resource is `analyze-attachments`;
+ * `summarize` is the designer's DeepRAG node (`manifest_node_deepRag_display_label:
+ * "Summarize"` in the vendored workbench strings) and its resource is `deep-rag`.
+ * Read off the platform's `builtInToolPropertiesSchemaV40` discriminated union
+ * (vendored `flow-to-bpmn.mjs`), which also lists `load-attachments` and
+ * `http-request`, and the uipath-agents skill's built-in-tools reference, which
+ * owns the file's body. The runtime ignores an unknown toolType silently, so
+ * this table is the whole contract — one that is wrong selects no tool at all.
+ */
+const BUILTIN_TOOL_TYPE = {
+    analyzefiles: 'analyze-attachments',
+    summarize: 'deep-rag',
+    batchtransform: 'batch-transform',
+};
+/** `inline` → `Inline`: the node's enum spelling to the resource schema's. */
+const enumValue = (v) => {
+    const s = String(v ?? '');
+    return s.charAt(0).toUpperCase() + s.slice(1);
+};
+/**
+ * The `resources/<id>/resource.json` of a platform BUILT-IN tool (#920) — the
+ * file the runtime builds the agent's tool list from. Without it the
+ * `tool.builtin.*` node is inert, the same failure #806 fixed for deployed
+ * resources: the agent runs with no built-in tool and the model never learns
+ * it exists.
+ *
+ * Derived from the node's own inputs (`tdef.inputDefaults` with the author's
+ * values over them), because those are what the file must agree with:
+ * `uip agent refresh --inline-in-flow` shell-ifies every resource node down to
+ * `{source, detail, itemsDescription}` and Studio Web re-hydrates the rest FROM
+ * this file, so a value only on the node does not survive a refresh or a
+ * designer round-trip.
+ *
+ * Shape: the skill's per-tool walkthroughs (`analyze-attachments.md`,
+ * `deeprag/impl-json.md`, `batch-transform/impl-json.md`) checked against the
+ * platform's `builtInToolResourceStorageSchemaV40`. Two vocabularies differ
+ * from the node's, as they do for a context index (`contextResourceJson`): the
+ * resource `query` is VARIANT-tagged where the node's is MODE-tagged, and its
+ * enums are capitalized (`Inline`, `Enabled`). `analyze-attachments` declares
+ * the model-facing call contract (`attachments` + `analysisTask` → `analysis`);
+ * `deep-rag` and `batch-transform` declare empty schemas and carry their
+ * configuration in `properties.settings`.
+ */
+function builtinToolResourceJson(tool, label, inputs, spec) {
+    const toolType = BUILTIN_TOOL_TYPE[tool];
+    if (toolType === undefined)
+        return undefined;
+    const empty = { type: 'object', properties: {} };
+    const common = {
+        $resourceType: 'tool',
+        id: spec.id,
+        // Null, not absent: what identifies a built-in as NOT an external tool.
+        referenceKey: null,
+        name: label,
+        type: 'internal',
+        description: String(inputs.description ?? ''),
+        isEnabled: true,
+        settings: {},
+        guardrail: { policies: [] },
+        argumentProperties: {},
+    };
+    const query = inputs.query?.mode === 'text-builder'
+        ? { variant: 'static', value: String(inputs.query.textValue ?? '') }
+        : { variant: 'dynamic', description: String(inputs.query?.promptValue ?? '') };
+    if (toolType === 'analyze-attachments') {
+        return {
+            ...common,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    attachments: {
+                        type: 'array',
+                        items: { $ref: '#/definitions/job-attachment' },
+                        description: String(inputs.attachmentsDescription ?? ''),
+                    },
+                    analysisTask: { type: 'string', description: String(inputs.analysisTaskDescription ?? '') },
+                },
+                required: ['attachments', 'analysisTask'],
+                definitions: {
+                    'job-attachment': {
+                        type: 'object',
+                        properties: {
+                            ID: { type: 'string', description: 'Orchestrator attachment key' },
+                            FullName: { type: 'string', description: 'File name' },
+                            MimeType: { type: 'string', description: 'MIME type, e.g. "application/pdf", "image/png"' },
+                            Metadata: {
+                                type: 'object',
+                                description: 'Dictionary<string, string> of metadata',
+                                additionalProperties: { type: 'string' },
+                            },
+                        },
+                        required: ['ID'],
+                        'x-uipath-resource-kind': 'JobAttachment',
+                    },
+                },
+            },
+            outputSchema: {
+                type: 'object',
+                properties: {
+                    analysis: {
+                        type: 'string',
+                        description: 'Analysis result of the attachments (analysis, summary, extracted information, etc.)',
+                    },
+                },
+                required: ['analysis'],
+            },
+            properties: { toolType, exampleCalls: [] },
+        };
+    }
+    if (toolType === 'deep-rag') {
+        return {
+            ...common,
+            inputSchema: empty,
+            outputSchema: empty,
+            properties: {
+                toolType,
+                exampleCalls: [],
+                settings: {
+                    contextType: 'attachments',
+                    query,
+                    folderPathPrefix: { variant: 'static' },
+                    fileExtension: { value: String(inputs.fileExtension?.value ?? 'pdf') },
+                    citationMode: { value: enumValue(inputs.citationMode?.value ?? 'inline') },
+                },
+            },
+        };
+    }
+    return {
+        ...common,
+        inputSchema: empty,
+        outputSchema: empty,
+        properties: {
+            toolType,
+            exampleCalls: [],
+            settings: {
+                contextType: 'attachments',
+                query,
+                folderPathPrefix: { variant: 'static' },
+                outputColumns: Array.isArray(inputs.outputColumns) ? inputs.outputColumns : [],
+                webSearchGrounding: { value: enumValue(inputs.webSearchGrounding?.value ?? 'enabled') },
+            },
+        },
+    };
+}
 /**
  * The one TARGET handle every tool resource declares: `input`, artifact-typed,
  * fed by the two agent types' `tool` handles. Transcribed from `registry get`
@@ -3959,16 +4108,38 @@ function misplacedLookupMessage(token) {
  * (`compile --no-check`, `emitFlow`, a direct `serialize()`) cannot write a
  * file `flow validate` rejects for a duplicate variable id.
  */
-function emittableGlobals(built, where) {
+function emittableGlobals(built, where, kind = 'root') {
     // Entry-point inputs are rows of the same globals[], so they share the
     // namespace; `check` reports those as ENTRY_POINT_INPUT_COLLISION.
     const inputs = [...built.inputs, ...(built.entryPoints ?? []).flatMap((ep) => ep.inputs)];
-    const plan = planFlowGlobals({ inputs, outputs: built.outputs, vars: built.vars });
+    // A variable an input feeds with `{ shared }` (#924) is one more `.var()`
+    // unless the author declared it, so it goes through the same collision plan.
+    const shared = sharedInputsOf(built, where, kind);
+    const plan = planFlowGlobals({ inputs, outputs: built.outputs, vars: [...built.vars, ...shared.autoVars] });
     if (plan.problems.length) {
         throw new Error(`${where}: ${plan.problems.map((p) => `[${p.code}] ${p.message}`).join(' ')}`);
     }
     return plan;
 }
+/**
+ * The flow's `{ shared }` input plan (#924), refused here as `check` refuses it
+ * — so `compile --no-check` cannot write what `check` would have stopped.
+ * Warnings (a root that feeds nothing) are `check`'s alone.
+ */
+function sharedInputsOf(built, where, kind) {
+    if (kind === 'subflow') {
+        const marked = built.inputs.filter((i) => i.shared !== undefined);
+        if (marked.length) {
+            throw new Error(`${where}: [SHARED_INPUT_IN_SUBFLOW] input "${marked[0].name}" has { shared: "${marked[0].shared}" }, but a subflow `
+                + `has one root — its caller — so there is nothing to merge. Read the input with input('${marked[0].name}').`);
+        }
+    }
+    const plan = planSharedInputs({ roots: sharedInputRoots(built), outputs: built.outputs, vars: built.vars });
+    const errors = plan.problems.filter((p) => p.level === 'error');
+    if (errors.length)
+        throw new Error(`${where}: ${errors.map((p) => `[${p.code}] ${p.message}`).join(' ')}`);
+    return plan;
+}
 function newScope(outputs, vars = []) {
     return {
         nodes: [],
@@ -4417,7 +4588,7 @@ export function serialize(built, opts = {}) {
      * a null. It is emitted here, always, so it cannot be forgotten.
      */
     function emitSubflowBody(child, nodeId) {
-        const childGlobals = emittableGlobals(child, `subflow "${nodeId}"`);
+        const childGlobals = emittableGlobals(child, `subflow "${nodeId}"`, 'subflow');
         const scope = newScope(childGlobals.outputs, childGlobals.vars);
         // Claim this copy's node ids UP FRONT, so the rename map is complete before
         // the first expression renders. A child's step names are free the first
@@ -5160,7 +5331,9 @@ export function serialize(built, opts = {}) {
                 // designer rather than guessed.
                 const toolResource = connectorTool
                     ? connectorToolResourceJson(connectorTool, toolResourceId)
-                    : toolResourceJson(tr, { id: toolResourceId });
+                    : tr.kind === 'builtin'
+                        ? builtinToolResourceJson(tr.tool, label, tnode.inputs, { id: toolResourceId })
+                        : toolResourceJson(tr, { id: toolResourceId });
                 if (toolResource !== undefined) {
                     sidecars.push({
                         path: `${source}/resources/${toolResourceId}/resource.json`,
@@ -6544,6 +6717,30 @@ export function serialize(built, opts = {}) {
             }
         }
     }
+    // ── Shared root inputs (#924) ────────────────────────────────────────────
+    // An input marked `{ shared: '<var>' }` is copied into that variable on its
+    // root's TRIGGER node: a `variableUpdates[<triggerId>]` row, the same
+    // construct `{ updates }` writes for a step. On the trigger, the copy is done
+    // before the root's own prefix steps run. The platform engine applies a start
+    // event's output rows in order, so the row sees the trigger's input mapping
+    // (measured live, #924). The default root's row is written against `start`
+    // and renamed with every other `input()` read, so `.triggerId()` follows.
+    {
+        const roots = [
+            { node: built.triggerId ?? 'start', read: 'start', inputs: built.inputs },
+            ...entryPoints.map((ep) => ({ node: ep.id, read: ep.id, inputs: ep.inputs })),
+        ];
+        for (const r of roots) {
+            const copies = {};
+            for (const inp of r.inputs) {
+                if (inp.shared !== undefined)
+                    copies[inp.shared] = new Expr(`$vars.${r.read}.output.${inp.name}`);
+            }
+            if (Object.keys(copies).length === 0)
+                continue;
+            root.variableUpdates[r.node] = [...(root.variableUpdates[r.node] ?? []), ...renderUpdates(copies, root.rename)];
+        }
+    }
     const globals = [];
     const triggerNodeId = built.triggerId ?? 'start';
     for (const inp of built.inputs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.15.6",
+  "version": "6.16.1",
   "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": "d8d72580682f02833d28d720ee382ffe9d346f6e"
+  "gitref": "5ccf1b7bf45b98185d2f79546df9c86a7dccc5bd"
 }