@uipath/maestro-builder-sdk 6.49.0 → 6.49.2

package/dist/bpmn/bpmn-sdk.d.ts

@@ -1157,16 +1157,19 @@ export interface DataServiceOpts extends ActivityOpts {
 export interface HttpOpts extends ActivityOpts {
     /** Display name the designer shows on the task. */
     name?: string;
-    /** Request URL. Accepts an `=`-expression, including `=bindings.<id>`. */
+    /**
+     * Request URL. Accepts an `=`-expression, including `=bindings.<id>`. In connector mode
+     * (see {@link HttpOpts.connection}) it is the endpoint on the target connector, relative
+     * to the connection's base URL, e.g. `/emoji.list`.
+     */
     url: string;
     /** HTTP method. Defaults to `'GET'`, matching the registry's own default. */
     method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
     /** Request headers — serialized to the node's json context field. */
     headers?: Record<string, unknown>;
     /**
-     * Query parameters — serialized to the node's json context field. In connector mode
-     * (see {@link HttpOpts.connection}) they are appended to the URL, so the URL must be
-     * a literal there.
+     * Query parameters — serialized to the node's json context field, or to the request's
+     * `query` in connector mode (see {@link HttpOpts.connection}).
      */
     parameters?: Record<string, unknown>;
     /**
@@ -1186,16 +1189,15 @@ export interface HttpOpts extends ActivityOpts {
      * @remarks
      * Without it the node is `Intsvc.UnifiedHttpRequest` in `mode="manual"`: the
      * process owns the URL, headers and auth, and nothing on the tenant is involved.
-     * With it the node is the connector activity the v1 skill calls "connector HTTP" —
-     * `Intsvc.ActivityExecution` on the generic HTTP connector (`uipath-uipath-http`,
-     * object `http-request`), whose `body` carries the request
-     * (`{"authentication":"connector","targetConnector":…,"connection":"=bindings.…","method":"GET","url":…,"path":…,"headers":…,"body":…}`)
-     * and whose auth is the connection's. That is the shape for "call an endpoint the
+     * With it the node is the V2 `Intsvc.UnifiedHttpRequest` in connector mode, as
+     * `uip maestro bpmn registry get Intsvc.UnifiedHttpRequest --connection-id` builds it:
+     * context `connectorKey` `uipath-uipath-http`, the connection bound, and a `body` row
+     * carrying the request
+     * (`{"authentication":"connector","method":"GET","targetConnector":…,"connection":…,"path":…,"url":…,"headers":…,"query":…,"body":…}`),
+     * whose auth is the connection's. A value that reads a variable is written `=js:`, as the
+     * CLI writes it (`=vars.x` becomes `=js:vars.x`). That is the shape for "call an endpoint the
      * connector catalog has no activity for, through an existing connection" — the
-     * non-catalog HTTP fallback — and it was not expressible before: in flow-v2-run-12
-     * both fallback cards (non-catalog-http-fallback, slack-http-fallback) authored a
-     * connectionless node because this option did not exist, and the grader found
-     * `connectorKey values seen: []`.
+     * non-catalog HTTP fallback.
      *
      * Pair it with {@link HttpOpts.folder}; both resolve as `.dataService()`'s do — an
      * existing binding by id, else `<id>_connection` / `<id>_folder` declared for you
@@ -1205,13 +1207,13 @@ export interface HttpOpts extends ActivityOpts {
      * belongs to one (see {@link HttpOpts.connectorKey}).
      */
     connection?: string;
-    /** Symbolic binding name of the connection's folder — connector mode only. */
+    /** Symbolic binding name of the connection's folder — connector mode only, where the CLI requires it. */
     folder?: string;
     /**
      * The connector the connection belongs to, connector mode only. Defaults to
      * `uipath-uipath-http`, the generic HTTP connector. Set it when the connection is a
      * specific connector's (a Slack connection calling a Slack endpoint the catalog does
-     * not expose); the body's `targetConnector` follows it.
+     * not expose); it becomes the request's `targetConnector`.
      */
     connectorKey?: string;
     /**
@@ -1226,7 +1228,11 @@ export interface HttpOpts extends ActivityOpts {
      * stays what the platform expects.
      */
     outputs?: Record<string, string>;
-    /** Variable the response lands in. Defaults to `<id>_response`. */
+    /**
+     * Variable the response lands in. Defaults to `<id>_response`. In connector mode it is
+     * the response body; the status code and headers land in `<id>_code` and `<id>_headers`,
+     * so it cannot be either.
+     */
     outputVar?: string;
     /** `=`-expression that skips the request when truthy. */
     skipCondition?: string;
@@ -2439,10 +2445,9 @@ declare abstract class ScopeBuilder {
     http(id: string, opts: HttpOpts, body?: ActivityBodyFn): this;
     /**
      * @internal Connector-mode `.http()`: the request through an Integration Service
-     * connection, as `Intsvc.ActivityExecution` on the generic HTTP connector's
-     * `http-request` object — the shape the v1 arm wrote by hand on flow-v2-run-12
-     * (non-catalog-http-fallback) and the live run completed. The connection and folder
-     * resolve exactly as `.dataService()`'s do.
+     * connection, as the V2 `Intsvc.UnifiedHttpRequest` element `uip maestro bpmn registry
+     * get Intsvc.UnifiedHttpRequest --connection-id` builds (see `managed-http.ts`). The
+     * connection and folder resolve exactly as `.dataService()`'s do.
      */
     private connectorHttp;
     /**

package/dist/bpmn/bpmn-sdk.js

@@ -5,6 +5,7 @@ import { schemaVersionRefusal } from '../schema-version.js';
 import { bindingRequiredFields, REGISTRY_GAPS, registryType } from './typed-node.js';
 import { resolveResourceKeyPattern } from './resource-key-pattern.js';
 import { DATA_SERVICE_ACTIVITY_TYPE, DATA_SERVICE_CONNECTOR_KEY, dataServiceWire } from './data-service.js';
+import { MANAGED_HTTP_CONNECTION_NAME, MANAGED_HTTP_CONNECTOR_KEY, MANAGED_HTTP_FOLDER_NAME, MANAGED_HTTP_TYPE, managedHttpContext, managedHttpInputs, managedHttpOutputs, } from './managed-http.js';
 import { ownEntry } from '../core/own-entry.js';
 export { BpmnBuildError } from './bpmn-expr-check.js';
 // @internal helpers kept on the published /bpmn subpath; SDK code imports declared-vars.js.
@@ -1032,79 +1033,46 @@ class ScopeBuilder {
     }
     /**
      * @internal Connector-mode `.http()`: the request through an Integration Service
-     * connection, as `Intsvc.ActivityExecution` on the generic HTTP connector's
-     * `http-request` object — the shape the v1 arm wrote by hand on flow-v2-run-12
-     * (non-catalog-http-fallback) and the live run completed. The connection and folder
-     * resolve exactly as `.dataService()`'s do.
+     * connection, as the V2 `Intsvc.UnifiedHttpRequest` element `uip maestro bpmn registry
+     * get Intsvc.UnifiedHttpRequest --connection-id` builds (see `managed-http.ts`). The
+     * connection and folder resolve exactly as `.dataService()`'s do.
      */
     connectorHttp(id, opts, body) {
-        const connectorKey = opts.connectorKey ?? 'uipath-uipath-http';
-        const connection = this.dataServiceBinding(id, 'connection', opts.connection, 'ConnectionId', `${connectorKey} connection`);
+        const codeVar = `${id}_code`;
+        const headersVar = `${id}_headers`;
+        if (opts.outputVar === codeVar || opts.outputVar === headersVar) {
+            throw new Error(`http "${id}": outputVar "${opts.outputVar}" is the variable connector mode writes the status code or headers to. ` +
+                `Pick another name, or drop outputVar for the default "${id}_response".`);
+        }
+        const connection = this.dataServiceBinding(id, 'connection', opts.connection, 'ConnectionId', MANAGED_HTTP_CONNECTION_NAME);
         const folder = opts.folder !== undefined
-            ? this.dataServiceBinding(id, 'folder', opts.folder, 'folderKey', `${connectorKey} folder`, connection.key)
+            ? this.dataServiceBinding(id, 'folder', opts.folder, 'folderKey', MANAGED_HTTP_FOLDER_NAME, connection.key)
             : undefined;
-        // The request's own URL, with `parameters` folded into its query string — the
-        // connector body has no separate parameters slot — and its path for the `path`
-        // field, which the v1 artifact carries beside the URL.
-        let url = opts.url;
-        let path;
-        if (!url.startsWith('=')) {
-            let parsed;
-            try {
-                parsed = new URL(url);
-            }
-            catch {
-                throw new Error(`http "${id}": connector mode needs an absolute URL (got ${JSON.stringify(url)}).`);
-            }
-            for (const [k, v] of Object.entries(opts.parameters ?? {}))
-                parsed.searchParams.set(k, String(v));
-            url = parsed.toString();
-            path = parsed.pathname;
-        }
-        else if (opts.parameters !== undefined) {
-            throw new Error(`http "${id}": connector mode appends \`parameters\` to the URL, so the URL cannot be an expression when they are given — ` +
-                `write them into the expression instead.`);
-        }
-        const responseVar = opts.outputVar ?? `${id}_response`;
+        const request = {
+            connection,
+            folder,
+            targetConnector: opts.connectorKey ?? MANAGED_HTTP_CONNECTOR_KEY,
+            method: opts.method ?? 'GET',
+            url: opts.url,
+            headers: opts.headers,
+            query: opts.parameters,
+            body: opts.body,
+        };
         return this.pushActivity({
             kind: 'typed',
             id,
             name: opts.name,
-            type: 'Intsvc.ActivityExecution',
-            context: {
-                activity: 'Create',
-                connectorKey,
-                connection: connection.ref,
-                ...(folder ? { folderKey: folder.ref } : {}),
-                operation: 'Create',
-                objectName: 'http-request',
-                method: 'POST',
-                path: '/http-request',
-                activityConfigurationVersion: 'v1',
-                metadata: {},
-            },
+            type: MANAGED_HTTP_TYPE,
+            context: {},
+            contextRows: managedHttpContext(request),
             inputs: {},
-            inputRows: [
-                {
-                    name: 'body',
-                    type: 'json',
-                    target: 'body',
-                    body: {
-                        authentication: 'connector',
-                        targetConnector: connectorKey,
-                        connection: connection.ref,
-                        method: opts.method ?? 'GET',
-                        url,
-                        ...(path !== undefined ? { path } : {}),
-                        headers: opts.headers ?? {},
-                        body: opts.body ?? null,
-                    },
-                },
-            ],
-            outputRows: [
-                { name: 'response', type: 'jsonSchema', source: '=response', var: responseVar },
-                { name: 'Error', type: 'jsonSchema', source: '=Error', var: `${id}_Error`, schema: errorSchema },
-            ],
+            inputRows: managedHttpInputs(request),
+            outputRows: managedHttpOutputs({
+                code: codeVar,
+                headers: headersVar,
+                body: opts.outputVar ?? `${id}_response`,
+                error: `${id}_Error`,
+            }),
             outputs: opts.outputs,
             skipCondition: opts.skipCondition,
             tags: opts.tags,

package/dist/bpmn/check.js

@@ -5,6 +5,7 @@ import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorLookups, che
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from '../core/event-checks.js';
 import { bindingRequiredFields, CASE_RUNTIME_INTERNAL_TYPES, missingRequiredContext, missingRequiredInputs, REGISTRY_GAPS, registryType, } from './typed-node.js';
 import { ownEntry } from '../core/own-entry.js';
+import { isManagedHttpV2, managedHttpAbsoluteUrl, managedHttpMissing } from './managed-http.js';
 /**
  * The job-start family — the types whose engine handler switches addressing on the
  * `uipath:type` version: v2 reads `name`/`folderPath`, v1 reads `releaseKey`/`folderKey`.
@@ -1391,7 +1392,12 @@ inEventSubProcess = false) {
             // emits, so whether this fired depended on a detail of the source document that
             // has nothing to do with whether the field is set.
             const contextNames = contextView;
-            for (const field of missingRequiredContext(n.type, contextNames, n.spec)) {
+            const managedHttp = isManagedHttpV2(n.type, contextNames);
+            const httpRequest = n.inputRows?.find((row) => row.name === 'body')?.body ?? n.inputs?.body;
+            const requiredContext = managedHttp
+                ? managedHttpMissing(contextNames, httpRequest)
+                : missingRequiredContext(n.type, contextNames, n.spec);
+            for (const field of requiredContext) {
                 diags.push({
                     level: 'error',
                     code: 'EMPTY_REQUIRED_FIELD',
@@ -1399,6 +1405,17 @@ inEventSubProcess = false) {
                     where: n.id,
                 });
             }
+            const absoluteUrl = managedHttp ? managedHttpAbsoluteUrl(httpRequest) : undefined;
+            if (absoluteUrl !== undefined) {
+                diags.push({
+                    level: 'warning',
+                    code: 'MANAGED_HTTP_ABSOLUTE_URL',
+                    message: `"${n.id}" (${n.type}) sends the absolute URL "${absoluteUrl.url}" through a ${absoluteUrl.targetConnector} connection. ` +
+                        `Integration Service refuses any host but that connector's with 400 "Invalid request URL". ` +
+                        `Write url relative to the connection's base URL, e.g. "/emoji.list" for Slack's https://slack.com/api/emoji.list.`,
+                    where: n.id,
+                });
+            }
             // The same rule over the PAYLOAD fields — the platform's RequiredFieldsRule
             // draws on both, so an unset required input is the same EMPTY_REQUIRED_FIELD.
             // The payload reaches a node the same two ways — `inputs`, or the verbatim

package/dist/bpmn/known-methods.d.ts

@@ -2,7 +2,7 @@
  * Method names the platform expects to be CALLED, not merely named.
  *
  * Generated — do not edit by hand. Run `node scripts/gen-bpmn-known-methods.mjs`
- * to refresh from the installed `@uipath/maestro-sdk`.
+ * to refresh from the installed `@uipath/maestro-validation`.
  *
  * The canvas validator's `METHOD_MISSING_PARENTHESES` rule reads this list: an
  * expression containing `.<name>` not followed by `(` is an ERROR when `<name>` is

package/dist/bpmn/known-methods.js

@@ -2,7 +2,7 @@
  * Method names the platform expects to be CALLED, not merely named.
  *
  * Generated — do not edit by hand. Run `node scripts/gen-bpmn-known-methods.mjs`
- * to refresh from the installed `@uipath/maestro-sdk`.
+ * to refresh from the installed `@uipath/maestro-validation`.
  *
  * The canvas validator's `METHOD_MISSING_PARENTHESES` rule reads this list: an
  * expression containing `.<name>` not followed by `(` is an ERROR when `<name>` is

package/dist/bpmn/managed-http.d.ts

@@ -0,0 +1,56 @@
+/**
+ * bpmn/managed-http — the wire shape behind connector-mode `.http()`: a V2
+ * `Intsvc.UnifiedHttpRequest` through an Integration Service connection, as
+ * `uip maestro bpmn registry get Intsvc.UnifiedHttpRequest --connection-id <id>` builds it
+ * (UiPath/cli `buildManagedHttpSpec` rendered by `renderBpmnV2Element`).
+ */
+import { MANAGED_HTTP_CONNECTOR_KEY } from '../core/managed-http.js';
+import type { TypedContextRow, TypedInputRow, TypedOutputRow } from './typed-node.js';
+export { MANAGED_HTTP_CONNECTOR_KEY };
+export declare const MANAGED_HTTP_TYPE = "Intsvc.UnifiedHttpRequest";
+/** The connection binding's name, after the node's `connectorKey`, as the CLI names it. */
+export declare const MANAGED_HTTP_CONNECTION_NAME = "uipath-uipath-http connection";
+export declare const MANAGED_HTTP_FOLDER_NAME = "FolderKey";
+/**
+ * True for a V2 HTTP request. `registry-types.json` holds the V1 manual node, whose
+ * required `url` and `mode` a V2 one does not carry.
+ */
+export declare function isManagedHttpV2(type: string, context: Record<string, unknown>): boolean;
+/** The required fields a V2 HTTP request leaves unset, a request field as `body.<key>`; `body` is its request row. */
+export declare function managedHttpMissing(context: Record<string, unknown>, body: unknown): string[];
+/**
+ * A connector request's absolute `url`, when the connector it goes through is not the generic
+ * HTTP one. Integration Service refuses a host other than the connector's with 400 "Invalid request URL".
+ */
+export declare function managedHttpAbsoluteUrl(body: unknown): {
+    url: string;
+    targetConnector: string;
+} | undefined;
+export interface ManagedHttpRequest {
+    /** `ref` is the `=bindings.<id>` reference; `key` the connection id it resolves to. */
+    connection: {
+        ref: string;
+        key: string;
+    };
+    folder?: {
+        ref: string;
+    };
+    /** The connector the connection belongs to. */
+    targetConnector: string;
+    method: string;
+    /** The endpoint on the target connector, e.g. `/emoji.list`. */
+    url: string;
+    headers?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+}
+export interface ManagedHttpVars {
+    code: string;
+    headers: string;
+    body: string;
+    error: string;
+}
+export declare function managedHttpContext(req: ManagedHttpRequest): TypedContextRow[];
+export declare function managedHttpInputs(req: ManagedHttpRequest): TypedInputRow[];
+/** Studio Web's curated HTTP outputs, then `Error`. */
+export declare function managedHttpOutputs(vars: ManagedHttpVars): TypedOutputRow[];

package/dist/bpmn/managed-http.js

@@ -0,0 +1,159 @@
+/**
+ * bpmn/managed-http — the wire shape behind connector-mode `.http()`: a V2
+ * `Intsvc.UnifiedHttpRequest` through an Integration Service connection, as
+ * `uip maestro bpmn registry get Intsvc.UnifiedHttpRequest --connection-id <id>` builds it
+ * (UiPath/cli `buildManagedHttpSpec` rendered by `renderBpmnV2Element`).
+ */
+import { MANAGED_HTTP_ACTIVITY_TYPE_ID, MANAGED_HTTP_CONNECTOR_KEY, MANAGED_HTTP_ENDPOINT, MANAGED_HTTP_ENDPOINT_METHOD, MANAGED_HTTP_ESSENTIAL_CONFIGURATION, MANAGED_HTTP_INSTANCE_PARAMETERS, MANAGED_HTTP_OBJECT_NAME, MANAGED_HTTP_TELEMETRY, } from '../core/managed-http.js';
+import { isRecord } from '../core/node-envelope.js';
+export { MANAGED_HTTP_CONNECTOR_KEY };
+export const MANAGED_HTTP_TYPE = 'Intsvc.UnifiedHttpRequest';
+/** The connection binding's name, after the node's `connectorKey`, as the CLI names it. */
+export const MANAGED_HTTP_CONNECTION_NAME = `${MANAGED_HTTP_CONNECTOR_KEY} connection`;
+export const MANAGED_HTTP_FOLDER_NAME = 'FolderKey';
+const CONNECTOR_VERSION = '1.4.50';
+const CONFIGURATION_VERSION = 'v2';
+const CONNECTOR_AUTHENTICATION = 'connector';
+/** Studio Web's guard on a JSON string it stores in node metadata. */
+const JSON_STRING_PREFIX = '=jsonString:';
+/** The CLI's `EXPRESSION_SHAPED`: a value Studio Web's V2 component reads as an expression only as `=js:`. */
+const EXPRESSION_SHAPED = /^=(vars|metadata|response|Error)\b/;
+/**
+ * The V2 contract's required context (UiPath/cli `manifest/bpmn-spec.json`), and the fields
+ * the CLI requires of a connector request (`managedHttpDetailErrors`).
+ */
+const REQUIRED_CONTEXT = ['connectorKey'];
+const CONNECTOR_REQUIRED_CONTEXT = ['folderKey'];
+const CONNECTOR_REQUIRED_BODY = ['targetConnector', 'connection'];
+const ABSOLUTE_URL = /^[a-z][a-z\d+.-]*:\/\//i;
+const ESSENTIAL_CONFIGURATION = {
+    essentialConfiguration: {
+        connectorVersion: CONNECTOR_VERSION,
+        executionType: null,
+        customFieldsRequestDetails: null,
+        ...MANAGED_HTTP_ESSENTIAL_CONFIGURATION,
+    },
+};
+/** The tenant-independent fields of Studio's TypeCache entry, which the CLI fetches live. */
+const CATALOG_ENTRY = {
+    displayName: 'HTTP Request',
+    description: 'Use HTTP requests to interact with APIs via the selected connector and connection configuration.',
+    category: '',
+    configuration: JSON.stringify({ ...MANAGED_HTTP_INSTANCE_PARAMETERS, supportsStreaming: false, subType: 'method' }),
+    uiPathActivityTypeId: MANAGED_HTTP_ACTIVITY_TYPE_ID,
+    isEnabled: true,
+};
+/**
+ * True for a V2 HTTP request. `registry-types.json` holds the V1 manual node, whose
+ * required `url` and `mode` a V2 one does not carry.
+ */
+export function isManagedHttpV2(type, context) {
+    return type === MANAGED_HTTP_TYPE && context.activityConfigurationVersion === CONFIGURATION_VERSION;
+}
+/** The required fields a V2 HTTP request leaves unset, a request field as `body.<key>`; `body` is its request row. */
+export function managedHttpMissing(context, body) {
+    const unset = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
+    const missingContext = REQUIRED_CONTEXT.filter((name) => unset(context[name]));
+    const request = connectorRequest(body);
+    if (request === undefined)
+        return missingContext;
+    return [
+        ...missingContext,
+        ...CONNECTOR_REQUIRED_CONTEXT.filter((name) => unset(context[name])),
+        ...CONNECTOR_REQUIRED_BODY.filter((name) => typeof request[name] !== 'string' || unset(request[name])).map((name) => `body.${name}`),
+    ];
+}
+/**
+ * A connector request's absolute `url`, when the connector it goes through is not the generic
+ * HTTP one. Integration Service refuses a host other than the connector's with 400 "Invalid request URL".
+ */
+export function managedHttpAbsoluteUrl(body) {
+    const request = connectorRequest(body);
+    if (request === undefined)
+        return undefined;
+    const { url, targetConnector } = request;
+    if (typeof url !== 'string' || typeof targetConnector !== 'string')
+        return undefined;
+    if (targetConnector === MANAGED_HTTP_CONNECTOR_KEY || !ABSOLUTE_URL.test(url))
+        return undefined;
+    return { url, targetConnector };
+}
+function connectorRequest(body) {
+    const request = typeof body === 'string' ? parseObject(body) : body;
+    return isRecord(request) && request.authentication === CONNECTOR_AUTHENTICATION ? request : undefined;
+}
+function parseObject(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** UiPath/cli `asDesignTimeExpressions`: `=vars.x` → `=js:vars.x`, at any depth; other text stays literal. */
+function designTimeExpressions(value) {
+    if (typeof value === 'string')
+        return EXPRESSION_SHAPED.test(value) ? `=js:${value.slice(1)}` : value;
+    if (Array.isArray(value))
+        return value.map(designTimeExpressions);
+    if (isRecord(value))
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, designTimeExpressions(v)]));
+    return value;
+}
+export function managedHttpContext(req) {
+    return [
+        { name: 'connectorKey', value: MANAGED_HTTP_CONNECTOR_KEY },
+        { name: 'connection', value: req.connection.ref },
+        { name: 'resourceKey', value: req.connection.key },
+        ...(req.folder ? [{ name: 'folderKey', value: req.folder.ref }] : []),
+        { name: 'method', value: MANAGED_HTTP_ENDPOINT_METHOD },
+        { name: 'path', value: MANAGED_HTTP_ENDPOINT },
+        { name: 'objectName', value: MANAGED_HTTP_OBJECT_NAME },
+        {
+            name: 'metadata',
+            type: 'json',
+            body: {
+                activityPropertyConfiguration: {
+                    configuration: `${JSON_STRING_PREFIX}${JSON.stringify(ESSENTIAL_CONFIGURATION)}`,
+                    uiPathActivityTypeId: MANAGED_HTTP_ACTIVITY_TYPE_ID,
+                    errorState: { issues: [] },
+                },
+                activityMetadata: { activity: CATALOG_ENTRY },
+                inputMetadata: {},
+                telemetryData: MANAGED_HTTP_TELEMETRY,
+            },
+        },
+        { name: 'activityConfigurationVersion', value: CONFIGURATION_VERSION },
+    ];
+}
+export function managedHttpInputs(req) {
+    const url = designTimeExpressions(req.url);
+    const body = {
+        authentication: CONNECTOR_AUTHENTICATION,
+        method: req.method,
+        targetConnector: req.targetConnector,
+        connection: req.connection.key,
+        path: url,
+        url,
+    };
+    if (req.headers !== undefined)
+        body.headers = designTimeExpressions(req.headers);
+    if (req.query !== undefined)
+        body.query = designTimeExpressions(req.query);
+    if (req.body !== undefined)
+        body.body = designTimeExpressions(req.body);
+    return [
+        { name: 'pathParameters', type: 'json', target: 'pathParameters', body: {} },
+        { name: 'queryParameters', type: 'json', target: 'queryParameters', body: {} },
+        { name: 'body', type: 'json', target: 'body', body },
+    ];
+}
+/** Studio Web's curated HTTP outputs, then `Error`. */
+export function managedHttpOutputs(vars) {
+    return [
+        { name: 'code', type: 'number', source: '=response.code', var: vars.code },
+        { name: 'headers', type: 'object', source: '=response.headers', var: vars.headers },
+        { name: 'body', type: 'object', source: '=response.body', var: vars.body },
+        { name: 'Error', type: 'jsonSchema', source: '=Error', var: vars.error },
+    ];
+}

package/dist/core/managed-http.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The managed HTTP request's fixed identity — Integration Service's generic HTTP
+ * connector, `POST /http-request` — shared by Flow's `core.action.http.v2` and BPMN's
+ * V2 `Intsvc.UnifiedHttpRequest`.
+ */
+export declare const MANAGED_HTTP_CONNECTOR_KEY = "uipath-uipath-http";
+export declare const MANAGED_HTTP_OBJECT_NAME = "http-request";
+export declare const MANAGED_HTTP_ENDPOINT = "/http-request";
+export declare const MANAGED_HTTP_ENDPOINT_METHOD = "POST";
+/** Studio's HTTP Request activity type, the same on every tenant. */
+export declare const MANAGED_HTTP_ACTIVITY_TYPE_ID = "5c4cc855-b42a-37e6-b910-de8588998fce";
+export declare const MANAGED_HTTP_INSTANCE_PARAMETERS: {
+    connectorKey: string;
+    objectName: string;
+    httpMethod: string;
+    activityType: string;
+    version: string;
+};
+/** The `essentialConfiguration` fields both hosts write, in the order they write them. */
+export declare const MANAGED_HTTP_ESSENTIAL_CONFIGURATION: {
+    instanceParameters: {
+        connectorKey: string;
+        objectName: string;
+        httpMethod: string;
+        activityType: string;
+        version: string;
+    };
+    objectName: string;
+    operation: string;
+    packageVersion: string;
+    httpMethod: string;
+    path: string;
+    unifiedTypesCompatible: boolean;
+    savedJitInputFieldId: string;
+};
+export declare const MANAGED_HTTP_TELEMETRY: {
+    connectorKey: string;
+    connectorName: string;
+    operationType: string;
+    objectName: string;
+    objectDisplayName: string;
+    primaryKeyName: string;
+};

package/dist/core/managed-http.js

@@ -0,0 +1,37 @@
+/**
+ * The managed HTTP request's fixed identity — Integration Service's generic HTTP
+ * connector, `POST /http-request` — shared by Flow's `core.action.http.v2` and BPMN's
+ * V2 `Intsvc.UnifiedHttpRequest`.
+ */
+export const MANAGED_HTTP_CONNECTOR_KEY = 'uipath-uipath-http';
+export const MANAGED_HTTP_OBJECT_NAME = 'http-request';
+export const MANAGED_HTTP_ENDPOINT = '/http-request';
+export const MANAGED_HTTP_ENDPOINT_METHOD = 'POST';
+/** Studio's HTTP Request activity type, the same on every tenant. */
+export const MANAGED_HTTP_ACTIVITY_TYPE_ID = '5c4cc855-b42a-37e6-b910-de8588998fce';
+export const MANAGED_HTTP_INSTANCE_PARAMETERS = {
+    connectorKey: MANAGED_HTTP_CONNECTOR_KEY,
+    objectName: MANAGED_HTTP_OBJECT_NAME,
+    httpMethod: MANAGED_HTTP_ENDPOINT_METHOD,
+    activityType: 'Curated',
+    version: '1.0.0',
+};
+/** The `essentialConfiguration` fields both hosts write, in the order they write them. */
+export const MANAGED_HTTP_ESSENTIAL_CONFIGURATION = {
+    instanceParameters: MANAGED_HTTP_INSTANCE_PARAMETERS,
+    objectName: MANAGED_HTTP_OBJECT_NAME,
+    operation: 'create',
+    packageVersion: '1.0.0',
+    httpMethod: MANAGED_HTTP_ENDPOINT_METHOD,
+    path: MANAGED_HTTP_ENDPOINT,
+    unifiedTypesCompatible: true,
+    savedJitInputFieldId: `in_${MANAGED_HTTP_OBJECT_NAME}`,
+};
+export const MANAGED_HTTP_TELEMETRY = {
+    connectorKey: MANAGED_HTTP_CONNECTOR_KEY,
+    connectorName: 'HTTP',
+    operationType: 'create',
+    objectName: MANAGED_HTTP_OBJECT_NAME,
+    objectDisplayName: 'HTTP Request',
+    primaryKeyName: '',
+};

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

@@ -8,6 +8,7 @@
  */
 import { Expr } from '../../../core/expr.js';
 import { jsonClone } from '../../../core/json-clone.js';
+import { MANAGED_HTTP_ACTIVITY_TYPE_ID, MANAGED_HTTP_ESSENTIAL_CONFIGURATION, MANAGED_HTTP_TELEMETRY, } from '../../../core/managed-http.js';
 import { isRecord } from '../../../core/node-envelope.js';
 import { wireExprBody } from '../../../core/wire-expr.js';
 import { checkHttpRead, checkHttpStep, plainHttpOnErrorMessage } from './check.js';
@@ -160,34 +161,10 @@ function managedHttpInputs(i, binding, ctx) {
             method: 'POST',
             endpoint: '/http-request',
             bodyParameters,
-            configuration: '=jsonString:' + JSON.stringify({
-                essentialConfiguration: {
-                    instanceParameters: {
-                        connectorKey: 'uipath-uipath-http',
-                        objectName: 'http-request',
-                        httpMethod: 'POST',
-                        activityType: 'Curated',
-                        version: '1.0.0',
-                    },
-                    objectName: 'http-request',
-                    operation: 'create',
-                    packageVersion: '1.0.0',
-                    httpMethod: 'POST',
-                    path: '/http-request',
-                    unifiedTypesCompatible: true,
-                    savedJitInputFieldId: 'in_http-request',
-                },
-            }),
-            uiPathActivityTypeId: '5c4cc855-b42a-37e6-b910-de8588998fce',
+            configuration: '=jsonString:' + JSON.stringify({ essentialConfiguration: MANAGED_HTTP_ESSENTIAL_CONFIGURATION }),
+            uiPathActivityTypeId: MANAGED_HTTP_ACTIVITY_TYPE_ID,
             errorState: { issues: [] },
-            telemetryData: {
-                connectorKey: 'uipath-uipath-http',
-                connectorName: 'HTTP',
-                operationType: 'create',
-                objectName: 'http-request',
-                objectDisplayName: 'HTTP Request',
-                primaryKeyName: '',
-            },
+            telemetryData: { ...MANAGED_HTTP_TELEMETRY },
         },
     };
 }

package/dist/registry/prepare/inherited-profile.d.ts

@@ -0,0 +1,14 @@
+import type { UipClient } from "../uip/client.js";
+/**
+ * Set by `uip` for the processes it starts: the login profile the run is for.
+ * Empty or unset means the default login.
+ */
+export declare const INHERITED_PROFILE_ENV = "UIPATH_CLI_INHERITED_PROFILE";
+/**
+ * Refuse unless the `uip` on PATH answers as `profile`.
+ *
+ * A `uip` older than {@link INHERITED_PROFILE_ENV} ignores it and reads the
+ * default login, which can be another customer's tenant, and nothing downstream
+ * notices (UiPath/cli#5485).
+ */
+export declare function assertInheritedProfile(client: UipClient, profile: string): Promise<void>;