@uipath/maestro-builder-sdk 6.16.0 → 6.16.1

package/dist/serialize.js

@@ -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`
@@ -5182,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`,

package/package.json

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