@uipath/maestro-builder-sdk 6.16.9 → 6.16.11

package/dist/compile-cli.js

@@ -21,7 +21,7 @@ import { reportDiagnostics, reportResult } from './cli-result.js';
 import { writeFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { resolveFlowFile, loadBuiltFlow } from './load.js';
-import { serializeWithSidecars, connectorInputErrors } from './serialize.js';
+import { serializeWithSidecars, connectorInputErrors, compileOwnsResource } from './serialize.js';
 import { check } from './check.js';
 import { byoaCheckOpts, eventResolveErrorFor, openCliLibrary } from './cli-library.js';
 import { Bindings } from './bindings.js';
@@ -31,32 +31,6 @@ import { ensureTypeScriptRuntime } from './node-runtime.js';
 import { defaultBindingsFile } from './workdir.js';
 import { BindingRefusal } from './core/binding-messages.js';
 import { ByoaRefusal } from './core/byoa.js';
-/**
- * The tool `type` values `compile` writes. NOT every `$resourceType: 'tool'`:
- * the designer writes kinds the SDK cannot derive into the same directory, so
- * pruning by `$resourceType` alone would delete theirs.
- *
- * `integration` (connector tools) is compile's since #867: compile writes the
- * file under the tool node's own `source` id, the same id and content `uip agent
- * refresh --inline-in-flow` derives from that node, so a file under any other id
- * belongs to a tool node the flow no longer has.
- */
-const COMPILE_OWNED_TOOL_TYPES = new Set([
-    'process', 'api', 'processOrchestration', 'flow', 'agent', 'function', 'integration',
-]);
-/**
- * Does `compile` own this resource file — i.e. would this run have written it,
- * so an unwritten one is stale rather than someone else's?
- *
- * Everything it says no to belongs to the designer (escalation, mcp, and the
- * kinds the SDK cannot derive).
- */
-function compileOwnsResource(body) {
-    const kind = body?.$resourceType;
-    if (kind === 'context')
-        return true;
-    return kind === 'tool' && COMPILE_OWNED_TOOL_TYPES.has(String(body?.type));
-}
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: compile <flow.ts | BaseName> [-o out.flow] [--library <dir>] [--bindings <file>]');
@@ -201,10 +175,11 @@ export async function run(argv) {
     // gone. Measured 2026-09-25 — compile with a context, remove it, recompile:
     // the file survives and refresh still reports `Resources: 1`.
     //
-    // Only the types THIS compile emits are pruned. `uip agent refresh` generates
-    // connector-tool resources into the same directory, and the designer writes
-    // the families the SDK cannot, so anything else found there is someone else's
-    // and is left alone.
+    // Only the types THIS compile emits are pruned — `compileOwnsResource`, which
+    // lives beside the writers and reads their tables. The designer writes the
+    // families the SDK cannot into the same directory (including `internal`
+    // built-ins such as `load-attachments`), so anything else found there is
+    // someone else's and is left alone.
     const staleBindings = [];
     const owned = new Set(sidecars
         .filter((s) => /\/resources\/[^/]+\/resource\.json$/.test(s.path))
@@ -238,7 +213,9 @@ export async function run(argv) {
             const key = typeof named === 'string' && named !== '' ? named : undefined;
             // A connector tool's binding is a `connection` row, and `mergeBindingsV2`
             // re-derives every connection row from the flow below — nothing to retract.
-            if (key !== undefined && body?.type !== 'integration') {
+            // A built-in (`internal`) tool binds nothing at all: retracting a `process`
+            // row under its label could only remove a real process tool's binding.
+            if (key !== undefined && body?.type !== 'integration' && body?.type !== 'internal') {
                 // Keyed the way refresh keys it: an index by its name, a deployed-resource
                 // tool under `process` whatever its own type says.
                 staleBindings.push({ resource: resourceType === 'context' ? 'index' : 'process', key });

package/dist/registry/prepare/connections.js

@@ -279,10 +279,21 @@ export function solutionConnectionIds(cwd, connectorKey) {
  * module's rule intact — ambiguity is never resolved by guessing.
  */
 export async function candidateConnections(client, connectorKey, name) {
+    // Both listings are always needed here, so they run at once: each is a `uip`
+    // process and a tenant round trip (~1 s each, measured in the n8n-vs-flow
+    // adhoc run of 2026-10-06), and neither depends on the other. Started in
+    // own-folder-then-tenant order, merged in that order, and a failure is
+    // reported in that order too — the result is what the sequential loop gave.
+    const settled = await Promise.allSettled([false, true].map((allFolders) => listConnections(client, { allFolders })));
+    const listings = settled.map((outcome) => {
+        if (outcome.status === "rejected")
+            throw outcome.reason;
+        return outcome.value;
+    });
     const ordered = [];
     const seen = new Set();
-    for (const allFolders of [false, true]) {
-        for (const row of enabledConnections(await listConnections(client, { allFolders }), connectorKey, name)) {
+    for (const listing of listings) {
+        for (const row of enabledConnections(listing, connectorKey, name)) {
             const identifier = pyStrAny(pyGet(row, "Id", ""));
             if (identifier && seen.has(identifier))
                 continue;

package/dist/serialize.d.ts

@@ -11,6 +11,31 @@ import { connectorInputErrors as coreConnectorInputErrors } from './core/connect
  * dropping it would make `check` quietly accept what `compile` throws on.
  */
 export declare function connectorInputErrors(rc: Parameters<typeof coreConnectorInputErrors>[0], inputs: Record<string, unknown>, resolutions?: Parameters<typeof coreConnectorInputErrors>[2], lookups?: Parameters<typeof coreConnectorInputErrors>[3]): string | undefined;
+/**
+ * Every tool resource identity `compile` writes, read off the tables its
+ * writers use — so a tool kind cannot be written without being owned, or owned
+ * without being written (#935: the #920 built-in files were written as
+ * `internal` and never pruned, because ownership was a hand-kept list in
+ * `compile-cli.ts` that did not have them).
+ *
+ *  * `types` — the resource `type`s compile owns OUTRIGHT: every deployed-resource
+ *    kind's, and `integration` (connector tools, since #867).
+ *  * `internalToolTypes` — `internal` is shared with designer-only built-ins
+ *    (`load-attachments`, `create-file`, `jev-classifier`), so for it ownership
+ *    is the `properties.toolType`, and only the ones compile writes.
+ */
+export declare const COMPILE_WRITTEN_TOOL_RESOURCES: {
+    readonly types: ReadonlySet<string>;
+    readonly internalToolTypes: ReadonlySet<string>;
+};
+/**
+ * Does `compile` own this `resources/<id>/resource.json` — would a compile have
+ * written it, so one this compile did not write is stale rather than someone
+ * else's? Everything it says no to belongs to the designer or to `uip agent
+ * refresh` (escalation, mcp, designer-only built-ins, the kinds the SDK cannot
+ * derive), and is never deleted.
+ */
+export declare function compileOwnsResource(body: Record<string, unknown> | undefined): boolean;
 /**
  * A compile-time observation that does not stop emission. `check()` has its
  * diagnostics; this is the serializer's own channel for things it can only see

package/dist/serialize.js

@@ -976,6 +976,16 @@ const TOOL_RESOURCE_TYPE = {
     process: 'process', api: 'api', maestro: 'processOrchestration',
     flow: 'flow', agent: 'agent', function: 'function',
 };
+/** The resource `type` of a connector tool's file ({@link connectorToolResourceJson}). */
+const CONNECTOR_TOOL_RESOURCE_TYPE = 'integration';
+/**
+ * The resource `type` of every platform built-in tool. Shared with tools the
+ * DESIGNER writes and the SDK cannot (`load-attachments`, `create-file`, …), so
+ * on its own it says nothing about who owns a file: `properties.toolType` does.
+ */
+const INTERNAL_TOOL_RESOURCE_TYPE = 'internal';
+/** The `properties.toolType` of the built-in HTTP-request tool's file (#935). */
+const HTTP_REQUEST_TOOL_TYPE = 'http-request';
 /**
  * The `resources/<id>/resource.json` a DEPLOYED-RESOURCE tool needs — the tool
  * half of what `contextResourceJson` does for an index, and inert for the same
@@ -1005,8 +1015,12 @@ const TOOL_RESOURCE_TYPE = {
  *    card, which are tenant reads.
  *  * `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.
+ *  * `httpRequest` — has its own writer, {@link httpRequestToolResourceJson}:
+ *    the file carries the request config as static `argumentProperties` and the
+ *    model-facing `inputSchema`, both derivable from the node (#935).
+ *
+ * Which `type`/`toolType` values compile writes — and so owns and may prune —
+ * is {@link compileOwnsResource}, read off the same tables these writers use.
  */
 function toolResourceJson(tr, spec) {
     const common = {
@@ -1107,7 +1121,7 @@ function builtinToolResourceJson(tool, label, inputs, spec) {
         // Null, not absent: what identifies a built-in as NOT an external tool.
         referenceKey: null,
         name: label,
-        type: 'internal',
+        type: INTERNAL_TOOL_RESOURCE_TYPE,
         description: String(inputs.description ?? ''),
         isEnabled: true,
         settings: {},
@@ -1197,6 +1211,102 @@ function builtinToolResourceJson(tool, label, inputs, spec) {
         },
     };
 }
+/**
+ * The six request fields of the HTTP-request tool, in the node's (and the
+ * designer's file's) order, with the JSON Schema each takes in the file's
+ * model-facing `inputSchema`. `headers`/`params` are name/value rows and
+ * `timeout` is a number — the same normalization the node's text-builder
+ * values already carry.
+ */
+const HTTP_REQUEST_FIELDS = [
+    ['url', { type: 'string' }],
+    ['method', { type: 'string' }],
+    ['headers', { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, value: { type: 'string' } } } }],
+    ['params', { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, value: { type: 'string' } } } }],
+    ['body', { type: 'string' }],
+    ['timeout', { type: 'number' }],
+];
+/**
+ * The `resources/<id>/resource.json` of the built-in HTTP-request tool (#935) —
+ * without it the deployed agent is never offered the tool (measured: one LLM
+ * call, no tool span), and `uip agent refresh --inline-in-flow` strips the node
+ * to `{source}`, so the request config is lost entirely.
+ *
+ * Derived from the node's own mode-tagged inputs, so the two halves cannot
+ * disagree. The rules are the ones Studio Web's own file follows (measured by
+ * saving the agent once in the designer; a file built by these rules is
+ * JSON-equal to it, and a debug run with only this file showed the tool spans):
+ *
+ *  * `inputSchema` declares all six fields, each with the node's `promptValue`
+ *    as its description — the text the model reads when it fills the field;
+ *  * `argumentProperties` pins every field NOT in `prompt` mode as
+ *    `$['<field>']: {variant: 'static', value: <textValue>}` — a fixed value the
+ *    model does not get to choose. The SDK writes only `prompt` and
+ *    `text-builder` fields; a `text-builder` value is the literal.
+ */
+function httpRequestToolResourceJson(label, inputs, spec) {
+    const properties = {};
+    const argumentProperties = {};
+    for (const [field, schema] of HTTP_REQUEST_FIELDS) {
+        const row = (inputs[field] ?? {});
+        properties[field] = { ...schema, description: String(row.promptValue ?? '') };
+        if (row.mode !== undefined && row.mode !== 'prompt') {
+            argumentProperties[`$['${field}']`] = { variant: 'static', value: row.textValue, isSensitive: false };
+        }
+    }
+    return {
+        $resourceType: 'tool',
+        id: spec.id,
+        canvasNodeId: spec.canvasNodeId,
+        name: label,
+        type: INTERNAL_TOOL_RESOURCE_TYPE,
+        description: String(inputs.description ?? ''),
+        isEnabled: true,
+        inputSchema: { type: 'object', properties, required: ['url'] },
+        outputSchema: { type: 'object', properties: {} },
+        settings: {},
+        guardrail: { policies: [] },
+        argumentProperties,
+        properties: { toolType: HTTP_REQUEST_TOOL_TYPE },
+    };
+}
+/**
+ * Every tool resource identity `compile` writes, read off the tables its
+ * writers use — so a tool kind cannot be written without being owned, or owned
+ * without being written (#935: the #920 built-in files were written as
+ * `internal` and never pruned, because ownership was a hand-kept list in
+ * `compile-cli.ts` that did not have them).
+ *
+ *  * `types` — the resource `type`s compile owns OUTRIGHT: every deployed-resource
+ *    kind's, and `integration` (connector tools, since #867).
+ *  * `internalToolTypes` — `internal` is shared with designer-only built-ins
+ *    (`load-attachments`, `create-file`, `jev-classifier`), so for it ownership
+ *    is the `properties.toolType`, and only the ones compile writes.
+ */
+export const COMPILE_WRITTEN_TOOL_RESOURCES = {
+    types: new Set([...Object.values(TOOL_RESOURCE_TYPE), CONNECTOR_TOOL_RESOURCE_TYPE]),
+    internalToolTypes: new Set([...Object.values(BUILTIN_TOOL_TYPE), HTTP_REQUEST_TOOL_TYPE]),
+};
+/**
+ * Does `compile` own this `resources/<id>/resource.json` — would a compile have
+ * written it, so one this compile did not write is stale rather than someone
+ * else's? Everything it says no to belongs to the designer or to `uip agent
+ * refresh` (escalation, mcp, designer-only built-ins, the kinds the SDK cannot
+ * derive), and is never deleted.
+ */
+export function compileOwnsResource(body) {
+    const kind = body?.$resourceType;
+    if (kind === 'context')
+        return true;
+    if (kind !== 'tool')
+        return false;
+    const type = String(body?.type);
+    if (type === INTERNAL_TOOL_RESOURCE_TYPE) {
+        const toolType = body?.properties?.toolType;
+        return COMPILE_WRITTEN_TOOL_RESOURCES.internalToolTypes.has(String(toolType));
+    }
+    return COMPILE_WRITTEN_TOOL_RESOURCES.types.has(type);
+}
 /**
  * The .NET type an Action Center app argument of each field type carries. Studio
  * Web serializes the task payload through `inputSchemaDotnetTypeMapping`, which
@@ -1654,7 +1764,7 @@ function connectorToolResourceJson(ctx, id) {
         name: ctx.name,
         description: ctx.description,
         location: 'external',
-        type: 'integration',
+        type: CONNECTOR_TOOL_RESOURCE_TYPE,
         inputSchema,
         outputSchema,
         settings: {},
@@ -5335,8 +5445,10 @@ export function serialize(built, opts = {}) {
                         fix('body', tr.body);
                     if (tr.timeout !== undefined)
                         fix('timeout', tr.timeout);
-                    if (tr.description !== undefined)
-                        extraInputs.description = tr.description;
+                    // Always set, falling back to the definition's own text: the resource
+                    // file hands this to the MODEL as the tool's description, and the node
+                    // must carry the same one (#935).
+                    extraInputs.description = tr.description ?? String(tdef.description ?? '');
                 }
                 else {
                     const meta = PROCESS_TOOL_META[tr.kind];
@@ -5390,7 +5502,9 @@ export function serialize(built, opts = {}) {
                     ? connectorToolResourceJson(connectorTool, toolResourceId)
                     : tr.kind === 'builtin'
                         ? builtinToolResourceJson(tr.tool, label, tnode.inputs, { id: toolResourceId })
-                        : toolResourceJson(tr, { id: toolResourceId });
+                        : tr.kind === 'httpRequest'
+                            ? httpRequestToolResourceJson(label, tnode.inputs, { id: toolResourceId, canvasNodeId: tid })
+                            : 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.9",
+  "version": "6.16.11",
   "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": "dd5b33d6640e176c10be173688ee2767cdd3f251"
+  "gitref": "aa02ee7f33c547e57d862b3ad18c1983cb291ba3"
 }