@uipath/maestro-builder-sdk 6.21.2 → 6.23.0

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

@@ -0,0 +1,411 @@
+/**
+ * The two HTTP node types: the standalone `core.action.http` (bundled at 1.0.0)
+ * and the managed `core.action.http.v2` (bundled at 2.3), routed through
+ * Integration Service's HTTP connector. They share the `http` kind; `managed`
+ * picks one (`matches`). Moved from serialize.ts / check.ts / decompile.ts in
+ * Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; serialized output, codes and
+ * messages unchanged. Decompile now also recovers `returns` (see `liftReturns`).
+ */
+import { Expr } from '../../../core/expr.js';
+import { jsonClone } from '../../../core/json-file.js';
+import { wireExprBody } from '../../../core/wire-expr.js';
+import { checkHttpRead, checkHttpStep, plainHttpOnErrorMessage } from './check.js';
+const PLAIN = 'core.action.http';
+const MANAGED = 'core.action.http.v2';
+/** The definition's `inputDefaults` at the version being emitted. */
+function defaults(ctx, typeName) {
+    return jsonClone(ctx.definition(typeName, ctx.version)?.inputDefaults ?? {});
+}
+/** A `{ name: value }` input map, each value rendered as the file stores it. */
+function renderMap(ctx, m) {
+    const out = {};
+    if (m)
+        for (const [k, v] of Object.entries(m))
+            out[k] = ctx.render(v);
+    return out;
+}
+/**
+ * `timeout` / `retryCount` — the two request settings BOTH http node types carry.
+ *
+ * **These fields were never MISSING from the emitted node.** Both definitions
+ * declare them in `inputDefaults` (`timeout: 'PT15M'`, `retryCount: 0`) and the
+ * `...defaults` spread has always carried them through, so every http node this
+ * SDK ever emitted already said fifteen minutes and no retries. What the author
+ * had no way to do was say anything ELSE — which is the actual gap, and why this
+ * spreads AFTER the defaults rather than instead of them.
+ *
+ * Emitting only-when-set therefore does two things at once: an author's value
+ * overrides the definition's, and an author who says nothing gets byte-for-byte
+ * what they got before. (~99% of the 808 deployed http nodes are on the
+ * defaults, so that is also the faithful shape.)
+ *
+ * `check` has already validated the FORM of both (`HTTP_TIMEOUT_NOT_DURATION`,
+ * `HTTP_RETRY_COUNT_INVALID`), so this writes them through verbatim.
+ */
+function httpRequestSettings(i) {
+    return {
+        ...(i.timeout !== undefined ? { timeout: i.timeout } : {}),
+        ...(i.retryCount !== undefined ? { retryCount: i.retryCount } : {}),
+    };
+}
+/** The `branches` rows both HTTP definitions declare: id/name from the author's name, conditions rendered like a decision's. */
+function httpBranchRows(i, ctx) {
+    if (!i.branches?.length)
+        return {};
+    return {
+        branches: i.branches.map((b) => ({
+            id: b.name,
+            name: b.name,
+            conditionExpression: ctx.renameRefs(b.condition.js),
+        })),
+    };
+}
+/** The standalone node's inputs: the request at the top level, beside the definition's defaults. */
+function plainHttpInputs(i, ctx) {
+    if (i.connection !== undefined
+        || i.folder !== undefined
+        || i.targetConnector !== undefined) {
+        throw new Error('standalone http cannot use Integration Service connection settings; set managed: true');
+    }
+    return {
+        ...defaults(ctx, PLAIN),
+        method: i.method ?? 'GET',
+        url: ctx.render(i.url),
+        headers: renderMap(ctx, i.headers),
+        queryParams: renderMap(ctx, i.query),
+        body: i.body !== undefined ? ctx.render(i.body) : '',
+        contentType: i.contentType ?? 'application/json',
+        ...httpRequestSettings(i),
+        ...httpBranchRows(i, ctx),
+    };
+}
+/**
+ * A managed step's Integration Service connection, resolved through bindings.json:
+ * undefined for the platform's manual/implicit mode (neither label given).
+ */
+function managedHttpBinding(i, ctx) {
+    const configured = i.connection !== undefined || i.folder !== undefined;
+    if (!configured)
+        return undefined;
+    if (typeof i.connection !== 'string' || i.connection.trim() === ''
+        || typeof i.folder !== 'string' || i.folder.trim() === '') {
+        throw new Error('managed http connection mode requires both a non-empty connection and folder');
+    }
+    // The same resolution a connector step gets: a self-referential binding is an
+    // error, a stub is a warning.
+    const where = `managed http "${ctx.step}"`;
+    return {
+        connectionId: ctx.resolveBinding(i.connection, 'connection', where),
+        folderKey: ctx.resolveBinding(i.folder, 'folder', where),
+    };
+}
+/**
+ * The MANAGED HTTP node's inputs (`core.action.http.v2`).
+ *
+ * The platform routes this one through Integration Service's own HTTP connector,
+ * so the request rides inside a connector `detail` envelope instead of sitting at
+ * the top level. Every constant below is read off the deployed corpus (384
+ * instances, 2026-05-11 → 07-29), not invented:
+ *
+ *   - `uiPathActivityTypeId` — ONE value across all 331 instances that carry it;
+ *   - `detail.method: 'POST'` + `endpoint: '/http-request'` — 352 of 352. That is
+ *     how the flow calls the CONNECTOR; the HTTP verb the connector performs
+ *     lives in `bodyParameters.method` (GET on 309). Two `method`s, one value
+ *     each, and swapping them silently turns every GET into a POST;
+ *   - `connectionId: 'ImplicitConnection'` — 290 of 352 (the rest bind an
+ *     explicit Integration Service connection);
+ *   - the `configuration` blob, whose `=jsonString:` envelope the platform reads
+ *     back as the activity's instance parameters.
+ */
+function managedHttpInputs(i, binding, ctx) {
+    if (i.targetConnector !== undefined && !binding) {
+        throw new Error('managed http targetConnector requires both a non-empty connection and folder');
+    }
+    if (i.targetConnector !== undefined
+        && (typeof i.targetConnector !== 'string' || i.targetConnector.trim() === '')) {
+        throw new Error('managed http targetConnector must be a non-empty connector key');
+    }
+    const url = ctx.render(i.url);
+    const bodyParameters = {
+        authentication: binding ? 'connector' : 'manual',
+        method: i.method ?? 'GET',
+        ...(binding ? {
+            targetConnector: i.targetConnector ?? 'uipath-uipath-http',
+            connection: binding.connectionId,
+            path: url,
+        } : {}),
+        url,
+    };
+    const headers = renderMap(ctx, i.headers);
+    if (Object.keys(headers).length > 0)
+        bodyParameters.headers = headers;
+    const query = renderMap(ctx, i.query);
+    if (Object.keys(query).length > 0)
+        bodyParameters.query = query;
+    if (i.body !== undefined)
+        bodyParameters.body = ctx.render(i.body);
+    return {
+        ...defaults(ctx, MANAGED),
+        ...httpBranchRows(i, ctx),
+        // TOP-LEVEL on the managed node too, NOT inside `detail` — the platform reads
+        // the request settings off the node, while `detail` is the connector call it
+        // wraps.
+        ...httpRequestSettings(i),
+        detail: {
+            connector: 'uipath-uipath-http',
+            connectionId: binding?.connectionId ?? 'ImplicitConnection',
+            connectionResourceId: binding?.connectionId ?? null,
+            connectionFolderKey: binding?.folderKey ?? null,
+            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',
+            errorState: { issues: [] },
+            telemetryData: {
+                connectorKey: 'uipath-uipath-http',
+                connectorName: 'HTTP',
+                operationType: 'create',
+                objectName: 'http-request',
+                objectDisplayName: 'HTTP Request',
+                primaryKeyName: '',
+            },
+        },
+    };
+}
+/**
+ * An HTTP node's declared parsed-JSON response shape, from the author's `returns`.
+ *
+ * The platform's own definition declares `output` as a bare object — only the API
+ * being called knows its body — so a `body.<field>` read is unresolvable until the
+ * author says what is in there. Same rule, same word, as `rpaWorkflow.returns`.
+ * Undefined when there is nothing to declare: the definition's outputs stand.
+ */
+function httpOutputs(base, returns, managed) {
+    if (!returns || Object.keys(returns).length === 0)
+        return undefined;
+    const out = jsonClone(base);
+    if (!out?.output)
+        return undefined;
+    // The whole `output` shape lives on the INSTANCE, not in the bundled
+    // definition — deliberately. An instance schema may refine a GENERIC definition
+    // object but never override one that already declares a
+    // shape, so declaring `body`/`statusCode` in the def would lock the author's
+    // `returns` out of the very read it exists to license. The definition stays
+    // byte-faithful to the platform's (a bare object, because only the API being
+    // called knows its body) and the author's declaration is the only source of
+    // shape — which is also what makes refusing a read with no `returns` correct.
+    out.output.properties = {
+        body: {
+            type: 'object',
+            description: managed
+                ? 'Response body, deserialized by Integration Service'
+                : 'JSON response body, deserialized by the standalone HTTP runtime',
+            properties: Object.fromEntries(Object.entries(returns).map(([name, type]) => [name, { type }])),
+        },
+        statusCode: { type: 'number', description: 'HTTP status code of the response' },
+    };
+    return out;
+}
+/** The vocabulary `returns` takes (`ReturnFieldType`). */
+const RETURN_FIELD_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'object', 'array']);
+/**
+ * The `returns` a step was authored with, read back off the body schema
+ * `httpOutputs` writes onto the instance (`outputs.output.properties.body`).
+ * Without it a decompiled flow that reads a body field no longer compiles
+ * (`HTTP_READ_WITHOUT_RETURNS`). Undefined when the node declares no body fields.
+ */
+function liftReturns(node) {
+    const props = node
+        ?.outputs?.output?.properties?.body?.properties;
+    if (!props || typeof props !== 'object')
+        return undefined;
+    // Only the types `returns` can name: a hand-edited schema's `null` or
+    // `date-time` would print source that no longer typechecks.
+    const entries = Object.entries(props)
+        .filter(([, v]) => typeof v?.type === 'string' && RETURN_FIELD_TYPES.has(v.type))
+        .map(([k, v]) => [k, v.type]);
+    return entries.length ? Object.fromEntries(entries) : undefined;
+}
+/**
+ * Invert an HTTP node. The plain node keeps its request at the top level
+ * (`url` / `method` / `headers` / `queryParams` / `body` / `contentType`); the
+ * managed node nests it inside `detail.bodyParameters` and routes through IS.
+ * Request settings (`timeout` / `retryCount`) sit at the top level on both, and
+ * are kept only when off their definition defaults, exactly as serialize writes
+ * them, so the round-trip stays minimal.
+ */
+function liftHttp(node, ctx, managed) {
+    const inputs = (node.inputs ?? {});
+    const detail = managed ? (inputs.detail ?? {}) : {};
+    const req = managed ? (detail.bodyParameters ?? {}) : inputs;
+    // A value as the author wrote it: an expression back to an Expr, a literal
+    // string as itself, any other JSON as is.
+    const value = (raw) => {
+        const text = Array.isArray(raw) ? undefined : ctx.sourceText(raw);
+        if (text === undefined)
+            return raw;
+        return text.startsWith('=js:') ? ctx.expr(text) : text;
+    };
+    const map = (m) => m && typeof m === 'object' && Object.keys(m).length
+        ? Object.fromEntries(Object.entries(m).map(([k, v]) => [k, value(v)]))
+        : undefined;
+    const text = (v) => (typeof v === 'string' ? v : undefined);
+    const connectionValue = detail.connectionId ?? detail.connectionResourceId ?? req.connection;
+    const retry = inputs.retryCount !== undefined && Number(inputs.retryCount) !== 0 ? Number(inputs.retryCount) : undefined;
+    if (retry !== undefined && !Number.isFinite(retry)) {
+        throw new Error(`decompile: expected a number, got ${JSON.stringify(inputs.retryCount)}.`);
+    }
+    const branchRows = Array.isArray(inputs.branches) ? inputs.branches : [];
+    const returns = liftReturns(node);
+    const spec = {
+        url: value(req.url ?? ''),
+        ...(text(req.method) !== undefined && req.method !== 'GET' ? { method: req.method } : {}),
+        ...(map(managed ? req.headers : inputs.headers) ? { headers: map(managed ? req.headers : inputs.headers) } : {}),
+        ...(map(managed ? req.query : inputs.queryParams) ? { query: map(managed ? req.query : inputs.queryParams) } : {}),
+        ...(req.body !== undefined && req.body !== '' ? { body: value(req.body) } : {}),
+        ...(!managed && text(inputs.contentType) !== undefined && inputs.contentType !== 'application/json'
+            ? { contentType: inputs.contentType } : {}),
+        managed,
+        ...(managed && typeof connectionValue === 'string' && connectionValue !== 'ImplicitConnection'
+            ? { connection: connectionValue } : {}),
+        ...(managed && typeof detail.connectionFolderKey === 'string' && detail.connectionFolderKey.length > 0
+            ? { folder: detail.connectionFolderKey } : {}),
+        ...(managed && typeof req.targetConnector === 'string' && req.targetConnector !== 'uipath-uipath-http'
+            ? { targetConnector: req.targetConnector } : {}),
+        ...(typeof inputs.timeout === 'string' && inputs.timeout !== 'PT15M' ? { timeout: inputs.timeout } : {}),
+        ...(retry !== undefined ? { retryCount: retry } : {}),
+        ...(branchRows.length ? {
+            branches: branchRows.map((b) => ({
+                name: String(b.name ?? b.id ?? ''),
+                condition: new Expr(wireExprBody(ctx.sourceText(b.conditionExpression) ?? '')),
+            })),
+        } : {}),
+        ...(returns ? { returns } : {}),
+    };
+    return { kind: 'http', inputs: spec };
+}
+/** The factory call decompile prints, options in the order the hand-written printer used. */
+function printHttp({ inputs: i }, ctx) {
+    // An expression as the helper an author writes; any other value as the data the node stores.
+    const val = (v) => (v instanceof Expr ? ctx.value(v) : ctx.json(v));
+    const map = (m) => m && Object.keys(m).length ? `{ ${Object.entries(m).map(([k, v]) => `${ctx.key(k)}: ${val(v)}`).join(', ')} }` : undefined;
+    const managed = i.managed === true;
+    const m = i;
+    return {
+        factory: 'http',
+        options: [
+            ['url', val(i.url)],
+            ['method', i.method !== undefined && i.method !== 'GET' ? ctx.string(i.method) : undefined],
+            ['headers', map(i.headers)],
+            ['query', map(i.query)],
+            ['body', i.body !== undefined ? val(i.body) : undefined],
+            ['contentType', i.contentType !== undefined ? ctx.string(i.contentType) : undefined],
+            ['managed', managed ? 'true' : 'false'],
+            ['connection', m.connection !== undefined ? ctx.string(m.connection) : undefined],
+            ['folder', m.folder !== undefined ? ctx.string(m.folder) : undefined],
+            ['targetConnector', m.targetConnector !== undefined ? ctx.string(m.targetConnector) : undefined],
+            ['timeout', i.timeout !== undefined ? ctx.string(i.timeout) : undefined],
+            ['retryCount', i.retryCount !== undefined ? ctx.json(i.retryCount) : undefined],
+            ['branches', i.branches?.length
+                    ? `[${i.branches.map((b) => `{ name: ${ctx.string(b.name)}, condition: ${ctx.value(b.condition)} }`).join(', ')}]`
+                    : undefined],
+            ['returns', i.returns && Object.keys(i.returns).length
+                    ? `{ ${Object.entries(i.returns).map(([k, t]) => `${ctx.key(k)}: ${ctx.string(String(t))}`).join(', ')} }`
+                    : undefined],
+        ],
+    };
+}
+/**
+ * The response branches the author declared, each on its `branch-<name>` port,
+ * and the fall-through `default`. The fall-through is an exit like any other
+ * here — it is what `.switch()` spells as its default arm, and leaving it out is
+ * the same omission as leaving out a branch.
+ */
+function httpExits({ inputs }) {
+    const branches = (inputs?.branches ?? []);
+    if (branches.length === 0) {
+        return {
+            reason: 'it declares no response branches',
+            suggestion: `branches: [{ name: 'rateLimited', condition: … }]`,
+        };
+    }
+    return [
+        ...branches.map((b) => ({ value: String(b?.name ?? ''), port: `branch-${b?.name ?? ''}` })),
+        { value: 'default', port: 'default', isDefault: true },
+    ];
+}
+function httpAt(typeName, version, managed) {
+    return {
+        kind: 'http', typeName, version, factory: 'http', definition: 'bundled',
+        rawNode: { factory: managed ? 'http({ managed: true })' : 'http({ managed: false })' },
+        // The plain node is not one: it publishes no envelope anywhere (`<step>.error`
+        // is `true`, `<step>.output` null), so check refuses a handler on it instead.
+        ...(managed ? { errorEnvelope: 'output' } : {}),
+        serialize: ({ inputs }, ctx) => {
+            const binding = managed ? managedHttpBinding(inputs, ctx) : undefined;
+            const nodeInputs = managed
+                ? managedHttpInputs(inputs, binding, ctx)
+                : plainHttpInputs(inputs, ctx);
+            const def = ctx.definition(typeName, ctx.version);
+            if (managed) {
+                // ImplicitConnection is the binding's default, not a remote resource key.
+                // Keeping the key empty matches product-authored manual HTTP nodes and
+                // lets the runtime supply the debug folder.
+                ctx.bindConnection({
+                    model: def?.model,
+                    connectorKey: 'uipath-uipath-http',
+                    connectionId: binding?.connectionId ?? 'ImplicitConnection',
+                    ...(binding ? { folderKey: binding.folderKey } : { resourceKey: '' }),
+                });
+            }
+            const outputs = httpOutputs(def?.outputDefinition, inputs.returns, managed);
+            return { inputs: nodeInputs, ...(outputs ? { outputs } : {}), port: 'default' };
+        },
+        deserialize: (node, ctx) => liftHttp(node, ctx, managed),
+        print: printHttp,
+        check: ({ inputs }, ctx) => checkHttpStep(inputs, ctx),
+        // The plain node's port exists (its definition declares it) but catches
+        // nothing a handler can read; see plainHttpOnErrorMessage.
+        ...(managed ? {} : {
+            checkErrorHandler: (_spec, ctx) => {
+                const { message, suggestion } = plainHttpOnErrorMessage(ctx.step);
+                ctx.report('HTTP_ONERROR_V1', message, suggestion);
+            },
+        }),
+        expressions: ({ inputs }) => [
+            { value: inputs.url },
+            { value: inputs.body },
+            ...Object.values(inputs.headers ?? {}).map((v) => ({ value: v })),
+            ...Object.values(inputs.query ?? {}).map((v) => ({ value: v })),
+            ...(inputs.branches ?? []).map((b) => ({ value: b.condition })),
+        ],
+        output: ({ inputs }) => ({ kind: 'reader', read: (read, report) => checkHttpRead(read, inputs, report) }),
+        exits: httpExits,
+    };
+}
+function httpType(typeName, version, managed) {
+    return {
+        kind: 'http', typeName, factory: 'http', defaultVersion: version,
+        versions: { [version]: httpAt(typeName, version, managed) },
+        matches: ({ inputs }) => Boolean(inputs?.managed) === managed,
+    };
+}
+export const httpNodeTypes = [httpType(PLAIN, '1.0.0', false), httpType(MANAGED, '2.3', true)];

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

@@ -0,0 +1,151 @@
+/**
+ * The HTTP family's authoring types (`core.action.http`, `core.action.http.v2`),
+ * and its kind's entry in `FlowActionSpecs`. Moved from core/actions.ts in
+ * Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md.
+ */
+import type { Expr } from '../../../core/expr.js';
+import type { ReturnFieldType } from '../../../core/actions.js';
+/** One conditional response branch on an HTTP node — a designer-visible side exit. */
+export interface HttpBranch {
+    /**
+     * The branch's name — it becomes the node's `branch-<name>` source port, so
+     * keep it port-safe (letters, digits, `_`, `-`). Route it with
+     * `.stepToList('branch-<name>', ...)` after the step; the main path continues
+     * from the default port as always.
+     */
+    name: string;
+    /**
+     * When to take this exit, evaluated against the response — e.g.
+     * js-tagged: `$vars.fetch.output.statusCode === 429`. Branches are checked in
+     * order; the first truthy one wins, else the default port fires.
+     */
+    condition: Expr;
+}
+interface HttpInputsBase {
+    /**
+     * Conditional response branches — extra source ports (`branch-<name>`)
+     * beside the default. See {@link HttpBranch}; both HTTP node families
+     * declare them.
+     */
+    branches?: HttpBranch[];
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    url: string | Expr;
+    headers?: Record<string, string | Expr>;
+    query?: Record<string, string | Expr>;
+    body?: string | Expr;
+    contentType?: string;
+    /**
+     * Choose the HTTP node explicitly. `false` emits the standalone
+     * `core.action.http`; `true` emits the managed `core.action.http.v2`, routed
+     * through Integration Service's HTTP connector.
+     *
+     * This has no default because these are different platform nodes, not two
+     * modes of one node. A silent `false` made an omitted field compile and
+     * validate as the wrong node while changing failure routing and connection
+     * behavior.
+     *
+     * It is not a version bump, it changes two things you can see:
+     *
+     * - **a 4xx/5xx FAILS the step**, so `.onError(…)` fires on it. On the plain
+     *   node the same 404 comes back on the SUCCESS path as
+     *   `out('fetch','statusCode')` and no error handler ever runs — which is why
+     *   an error port only makes sense here (`check` says so: HTTP_ONERROR_V1).
+     *   The handler can answer the flow (`.return`), stop the run
+     *   (`.terminate`), or compensate and continue at a step the success path
+     *   also reaches (`h.stepToRef('<step>')` — see `references/error-handling.md`);
+     * - both nodes expose JSON responses as parsed values in the live product;
+     *   use `returns` to declare fields before reading them. The node choice does
+     *   not decide whether application/json is parsed.
+     *
+     * With `managed: true`, omit `connection` and `folder` for the platform's
+     * manual/implicit mode, or provide both symbolic names to reuse an Integration
+     * Service HTTP connection. A local run remains unauthenticated.
+     *
+     * @enforcedBy HTTP_ONERROR_V1 `.onError()` on an http step needs `managed: true`; on
+     * the standalone node a 4xx arrives on the SUCCESS path and no handler runs.
+     */
+    managed: boolean;
+    /**
+     * The response BODY's top-level fields and their types — e.g.
+     * `{ items: 'array' }`. Required for either HTTP node if anything reads a
+     * field off a parsed JSON body.
+     *
+     * Why you have to say: the platform's own definition declares the response as
+     * a bare object, because only the API being called knows its shape. Without
+     * this, `out('fetch','body','items')` reads from an object with no declared
+     * fields, and nothing downstream can tell a real field from a typo. Same rule,
+     * and the same word, as
+     * `rpaWorkflow`'s `returns`.
+     *
+     * **Where a declared field is read:** under `body`, never beside it. The
+     * response is an envelope — `{ body, statusCode, headers }` — and these are the
+     * body's fields, so `returns: { items: 'array' }` is read as
+     * `out('fetch', 'body.items')`, which is `$vars.fetch.output.body.items`.
+     * `$vars.fetch.output.items` is undefined at run time.
+     *
+     * @enforcedBy HTTP_READ_UNKNOWN_FIELD A read must be `output.body.<declared field>`,
+     * `output.statusCode` or `output.headers`.
+     * @enforcedBy HTTP_READ_WITHOUT_RETURNS Reading a body field requires declaring it here.
+     */
+    returns?: Record<string, ReturnFieldType>;
+    /**
+     * How long to wait for the response before giving up, as an **ISO-8601
+     * duration** — `'PT30S'` is "give up after 30 seconds", `'PT1M'` one minute,
+     * `'PT15M'` fifteen.
+     *
+     * Both http node types carry this, and both definitions declare the same
+     * default (`PT15M`), so leaving it unset is not "no timeout" — it is fifteen
+     * minutes. Omitted from the emitted node unless you set it, which keeps a flow
+     * that doesn't care byte-identical to the platform's own default shape (~99%
+     * of the 808 deployed http nodes are on the defaults).
+     *
+     * `check` rejects a string the platform cannot parse as a duration —
+     * `'30s'`, `'PT'` and `'30'` are all errors that name the expected form.
+     *
+     * @defaultValue `'PT15M'`
+     * @enforcedBy HTTP_TIMEOUT_NOT_DURATION Must be an ISO-8601 duration.
+     */
+    timeout?: string;
+    /**
+     * How many times to RETRY a retryable failure (5xx, 429, a network error) —
+     * `0`, the definitions' default, means "try once, don't retry". `2` means up
+     * to three attempts in total.
+     *
+     * Must be a non-negative integer. Above **5** `check` warns rather than
+     * errors: the deployed corpus's
+     * largest author-set value is 3, and the platform's own ceiling is not
+     * measured — so a bigger number may well work, and refusing it outright would
+     * fence off something we have no evidence is wrong.
+     *
+     * @defaultValue `0`
+     * @enforcedBy HTTP_RETRY_COUNT_INVALID Must be a non-negative integer.
+     */
+    retryCount?: number;
+}
+export type HttpInputs = HttpInputsBase & ({
+    managed: false;
+    connection?: never;
+    folder?: never;
+} | {
+    managed: true;
+    /** Symbolic HTTP connection name declared in bindings.json. */
+    connection?: string;
+    /** Symbolic folder name declared in bindings.json. */
+    folder?: string;
+    /**
+     * Connector key whose authentication the HTTP proxy should reuse.
+     * Defaults to `uipath-uipath-http`. Set this for a connector-specific
+     * fallback endpoint, for example `uipath-salesforce-slack`.
+     * Requires both `connection` and `folder`.
+     */
+    targetConnector?: string;
+});
+declare module '../../../core/actions.js' {
+    interface FlowActionSpecs {
+        /** The spec {@link http} builds. */
+        http: {
+            inputs: HttpInputs;
+        };
+    }
+}
+export {};

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

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

package/dist/serialize.d.ts

@@ -95,8 +95,8 @@ export declare function serializeWithSidecars(built: BuiltFlow, opts?: Serialize
  * agenticProcess, publishedFunction, agent, ixpExtract) and for a spec this SDK
  * does not lower by kind.
  *
- * The http / transform / delay / script emit path reads its type from here too,
- * so the answer `check` gets is the type `serialize` writes.
+ * A registered kind (flow-node-registry.ts) is not listed: its type is the
+ * registry's.
  */
 export declare function bundledActionNodeType(spec: {
     kind?: string;