@celigo/api-specs 0.2.206 → 0.2.207

package/dist/api.yml

@@ -8505,10 +8505,12 @@ components:
                 `targetConcurrencyLevel`. While true, `targetConcurrencyLevel` is the throughput lever: a
                 `concurrencyLevel` sent in a PUT is ignored, and one sent in a PATCH is stored but the
                 recovery machinery moves it back toward the target. Recovery never runs on `ftp`
-                connections: FTP errors aren't treated as rate limits.
+                connections: FTP errors aren't treated as rate limits. A rate limit hit by a Tool
+                invocation (`POST /v1/tools/{_id}/invoke`) or an export preview
+                (`POST /v1/exports/preview`) leaves the connection's concurrency as it is.
               x-celigo-ai-guidance:
                 - To change throughput while this is true, write `targetConcurrencyLevel`; a `concurrencyLevel` sent in a PUT returns 200 and changes nothing.
-                - Turning it on copies `concurrencyLevel` into `targetConcurrencyLevel`; turning it off unsets the target and leaves `concurrencyLevel` at its current value, which may be below the old target if a recovery was in progress. A `targetConcurrencyLevel` written while this is false is unset by the save.
+                - Turning it on copies `concurrencyLevel` into `targetConcurrencyLevel`; turning it off unsets the target and leaves `concurrencyLevel` at its current value, which may be below the old target if a recovery was in progress. A `targetConcurrencyLevel` sent on a create that sets this false, or with the write that turns this off, is dropped; on a connection where this is already false, writing one fails with 422 `invalid_concurrency_level`.
                 - These four settings (`concurrencyLevel`, `targetConcurrencyLevel`, `_borrowConcurrencyFromConnectionId`, this flag) accept a credential-free `PATCH /v1/connections/{_id}`. A PUT replaces the whole document, so send each secret back as its masked `******` value (that keeps it) or as a new value, and never drop one to keep it — an omitted password or `http.encrypted` is cleared, and a static token left out (with no `refreshMethod`) fails the PUT with 422.
                 - On a create, while this is true, set the level with `targetConcurrencyLevel`: on `http`, `ftp`, `rdbms` and `mongodb` connections the save stores the target sent, or the adaptor's default without one (1 for `ftp`, 5 for `rdbms` and `mongodb`, 25 for `http` where the license's `concurrency` is at least 25), as both fields, whatever `concurrencyLevel` the body carried. A create that sends this as `false` keeps its `concurrencyLevel`.
                 - On an `ftp` connection recovery never runs, and transfer threads are `ftp.multiThreadCount`.
@@ -9145,8 +9147,10 @@ components:
             While `autoRecoverRateLimitErrors` is true, a create sets `concurrencyLevel` to this value, and a
             create that omits it gets 1 for both. Auto-recovery never runs on FTP connections (FTP errors
             aren't treated as rate limits), so nothing climbs back to it.
-            Kept on a `PUT` that omits it, like `concurrencyLevel`; unset by the save while
-            `autoRecoverRateLimitErrors` is false.
+            Kept on a `PUT` that omits it, like `concurrencyLevel`. A create that sends
+            `autoRecoverRateLimitErrors` false, or a write that turns it off, drops it; on a connection
+            where the flag is already false, sending it fails with 422 `invalid_concurrency_level`
+            ("cannot be set when autoRecoverRateLimitErrors is false").
           minimum: 1
           maximum: 50
           examples:
@@ -9887,9 +9891,10 @@ components:
             Higher values increase throughput but may trigger API rate limits.
             Set this based on the target API's rate limit documentation.
             Send no more than the account's licensed maximum (25 standard, 50 with an Environments license).
-            A decimal is rejected with 422 `invalid_field_value` on every write (the same rule applies to every
-            adaptor's `concurrencyLevel` and `targetConcurrencyLevel`, and to `ftp.multiThreadCount`).
-            Platform-managed while `autoRecoverRateLimitErrors` is true — a create or PUT ignores the value (a create without `targetConcurrencyLevel` stores 25 where the license's `concurrency` is at least 25) and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
+            A create, a PATCH, and a PUT while `autoRecoverRateLimitErrors` is false reject a decimal with 422
+            `invalid_field_value` and a boolean or a non-numeric string with 422 `invalid_concurrency_level`
+            ("must be an integer").
+            Platform-managed while `autoRecoverRateLimitErrors` is true — a create still checks the value but stores the target in its place (25 without a `targetConcurrencyLevel`, where the license's `concurrency` is at least 25), a PUT ignores it without checking it, and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
             At level 1 an import's pages run one at a time, so a record's existence lookup and write finish before the next record's start (measured on a single import); the import's `idLockTemplate` serializes only same-key records and leaves the rest parallel.
           minimum: 1
           maximum: 50
@@ -9902,7 +9907,9 @@ components:
             Ceiling the platform climbs back to after rate-limit recovery, in steps of 25% of this value.
             Writing it also sets `concurrencyLevel` to the same value and stops any recovery in progress.
 
-            Honored only while `autoRecoverRateLimitErrors` is true; ignored, and unset, when it is false.
+            Honored only while `autoRecoverRateLimitErrors` is true. A create that sends the flag as false, or a
+            write that turns it off, drops it; on a connection where the flag is already false, sending it fails with 422
+            `invalid_concurrency_level` ("cannot be set when autoRecoverRateLimitErrors is false").
           minimum: 1
           maximum: 50
           examples:
@@ -10673,6 +10680,26 @@ components:
               examples:
                 - - rate_limit_exceeded
                   - too_many_requests
+            failHeaders:
+              type: array
+              description: |
+                Response-header rules for detecting rate limiting, each a header `name` with an
+                optional `value`. A rule with an empty `name` fails the save with 422
+                `invalid_header_format`.
+              items:
+                type: object
+                required:
+                  - name
+                properties:
+                  name:
+                    type: string
+                    description: Response header the rule checks.
+                  value:
+                    type: string
+                    description: Header value the rule checks; omit to check the header alone.
+              examples:
+                - - name: X-RateLimit-Remaining
+                    value: '0'
             limit:
               type: number
               minimum: 1

package/dist/connection.yml

@@ -844,8 +844,9 @@ paths:
 
         Three settings are the exception and survive an omission: `endUserProvidedFields`
         (send `null` to clear it — `[]` is treated like an omission), and on `ftp` connections
-        `ftp.concurrencyLevel` and `ftp.targetConcurrencyLevel` (the latter is unset whenever
-        `autoRecoverRateLimitErrors` is false). `connectionRole` is read-only here: a body carrying
+        `ftp.concurrencyLevel` and `ftp.targetConcurrencyLevel` (the latter is dropped by the PUT that
+        turns `autoRecoverRateLimitErrors` off, and sending it on a connection where the flag is already
+        false fails with 422 `invalid_concurrency_level`). `connectionRole` is read-only here: a body carrying
         `mcpChild` is rejected.
 
         An OAuth connection's `http.auth.oauth.authURI` and `tokenURI` can't change: a body that
@@ -1022,18 +1023,21 @@ paths:
         | `/debugDate` | Debug logging expiry (ISO-8601, max 1 hour from now) |
         | `/debugUntil` | Alias for `/debugDate` |
         | `/<adaptor>/concurrencyLevel` | Concurrent requests allowed. Platform-managed while `autoRecoverRateLimitErrors` is true — the recovery machinery moves it toward the target, so set `targetConcurrencyLevel` instead |
-        | `/<adaptor>/targetConcurrencyLevel` | Ceiling auto-recovery climbs back to. Persists only while `autoRecoverRateLimitErrors` is true; while false the save unsets it |
+        | `/<adaptor>/targetConcurrencyLevel` | Ceiling auto-recovery climbs back to. Accepted only while `autoRecoverRateLimitErrors` is true; while it is false the patch fails with 422 `invalid_concurrency_level` |
         | `/_borrowConcurrencyFromConnectionId` | Share another connection's concurrency budget. `remove` clears it |
         | `/autoRecoverRateLimitErrors` | Rate-limit auto-recovery toggle. Turning it on copies the current level into the target; turning it off unsets the target and leaves the level at its current value |
+        | `/http/rateLimit/failStatusCode`, `/http/rateLimit/failPath`, `/http/rateLimit/failHeaders` | Rate-limit detection rules. Send `failHeaders` as the whole array; on one element only `replace` of an existing entry works (e.g. `/http/rateLimit/failHeaders/0`), and `add` or `remove` on an element fails with 422 |
+        | `/http/rateLimit/limit` | Requests per rate-limit window. Accepted only at a concurrency of 1: set `/http/targetConcurrencyLevel` (while `autoRecoverRateLimitErrors` is true) or `/http/concurrencyLevel` (while it is false) to 1 in the same patch; at any other level it fails with 422 `invalid_concurrency_level` |
         | `/endUserProvidedFields` | Dot-paths MCP end users must supply on their own child copy of this connection. `replace` with `[]` or `remove` clears the list, and `add` on `/endUserProvidedFields/-` appends one path; a path the account owns (`type`, `_agentId`, `wrapper._stackId`, any `<adaptor>._iClientId`) is rejected |
 
         `replace` and `add` both set the value (a currently unset field is fine);
         `remove` unsets it. A `null` value is rejected. Any other path — including
         `/connectionRole`, `/netsuite/concurrencyLevelRESTlet`,
-        `/netsuite/concurrencyLevelWebServices` and `rateLimit` fields — fails with
-        `<path> is not a whitelisted property`.
+        `/netsuite/concurrencyLevelWebServices`, `/http/rateLimit` as a whole and
+        `/http/rateLimit/failValues` — fails with `<path> is not a whitelisted property`.
         Concurrency values must be whole numbers within the account's licensed
-        range (a decimal fails with 422 `invalid_field_value`). A whitelisted path under an adaptor
+        range (a decimal fails with 422 `invalid_field_value`, a boolean or non-numeric
+        string with 422 `invalid_concurrency_level`). A whitelisted path under an adaptor
         block the connection does not use is accepted but never read. The
         borrowed-from connection must exist in the account and may not itself borrow
         (422 `connection_borrows_from_another`), and a connection that others borrow
@@ -1621,11 +1625,14 @@ paths:
         Adaptors `POST /v1/imports/preview` rejects with `invalid_adaptor` run
         here — NetSuite and RDBMS verified alongside HTTP.
 
-        The step runs with the document's own `settings` only: hooks receive
-        `options.settings` with an `import` key but no `integration` or `flow`
-        key and no `_flowId` / `_integrationId`; `{{settings.integration.*}}`
-        and `{{settings.flow.*}}` templates render empty. To run the document
-        with the context a real run of its parent supplies, use the
+        The step runs without integration or flow context: hooks receive
+        `options.settings` with the document's `import` settings (and
+        `connection` when the connection has settings) but no `integration` or
+        `flow` key and no `_flowId` / `_integrationId`. A
+        `{{settings.integration.*}}` or `{{settings.flow.*}}` template renders
+        empty in a body; in an HTTP `relativeURI` it fails the record with 422
+        `handlebars_template_parse_error`. To run the document with the
+        context a real run of its parent supplies, use the
         integration-scoped forms —
         `POST /v1/integrations/{_integrationId}/flows/{_flowId}/connections/{_connectionId}/import`
         and the `tools/{_toolId}` and `apis/{_apiId}` siblings. The connection
@@ -1658,10 +1665,12 @@ paths:
                   This executes the request against the live destination — a real write, even when the
                   document carries a saved `mockResponse`. Treat it like a flow run, never like a preview.
                 - |-
-                  The step gets the document's own settings only: hooks see `options.settings = {import}`
-                  with no `integration` / `flow` key and no `_flowId` / `_integrationId`, and
-                  `{{settings.integration.*}}` / `{{settings.flow.*}}` render empty. A step whose hooks or
-                  templates read those settings builds a different record here than in a flow run — send
+                  The step gets no integration or flow context: hooks see `options.settings` with `import`
+                  (and `connection` when the connection has settings) but no `integration` / `flow` key and
+                  no `_flowId` / `_integrationId`; `{{settings.integration.*}}` / `{{settings.flow.*}}`
+                  render empty in a body and fail the record with 422 `handlebars_template_parse_error` in
+                  an HTTP `relativeURI`. A step whose hooks or templates read those settings builds a
+                  different record here than in a flow run — send
                   it through the integration-scoped form
                   (`/v1/integrations/{_integrationId}/flows/{_flowId}/connections/{_connectionId}/import`,
                   or the `tools` / `apis` sibling) instead, which resolves that context from the URL.
@@ -1969,13 +1978,13 @@ paths:
       description: |-
         Runs an import document sent in the request body — a virtual import —
         through the connection, with the flow and the integration in the
-        path supplying the execution context a real run gives the step — hooks receive `options.settings` with the flow's and the integration's settings (a resource with none contributes no key) plus `_flowId` / `_integrationId`, as on the flow's own preview chain.
+        path supplying the execution context a real run gives the step — hooks receive `options.settings` with the flow's, the integration's and the connection's settings (a resource with none contributes no key) plus `_flowId` / `_integrationId`, as on the flow's own preview chain.
         Nothing is saved — the document can be an unsaved draft, a modified
         copy, or a saved import as fetched — and the request executes against
         the live destination: a real write; a saved
         `mockResponse` does not substitute. Pipeline and per-record result are
         those of `POST /v1/connections/{_id}/import`, which runs the document
-        with its own settings only. The flow must belong to the
+        without integration or flow context. The flow must belong to the
         integration, the connection must be registered to it, and the caller
         needs manage access to the account or the integration.
       parameters:
@@ -2147,13 +2156,13 @@ paths:
       description: |-
         Runs an import document sent in the request body — a virtual import —
         through the connection, with the tool and the integration in the
-        path supplying the execution context — hooks receive `options.settings` with the integration's settings (none when it carries none) plus `_integrationId`, and no flow. That is more than a step gets in a real run of the tool, which sees no integration settings and no `_integrationId`.
+        path supplying the execution context — hooks receive `options.settings` with the integration's and the connection's settings (a resource with none contributes no key) plus `_integrationId`, and no flow. That is more than a step gets in a real run of the tool, which sees no integration settings and no `_integrationId`.
         Nothing is saved — the document can be an unsaved draft, a modified
         copy, or a saved import as fetched — and the request executes against
         the live destination: a real write, not a dry run; a saved
         `mockResponse` does not substitute. Pipeline and per-record result are
         those of `POST /v1/connections/{_id}/import`, which runs the document
-        with its own settings only. The tool must belong to the
+        without integration or flow context. The tool must belong to the
         integration, the connection must be registered to it, and the caller
         needs manage access to the account or the integration.
       parameters:
@@ -2325,13 +2334,13 @@ paths:
       description: |-
         Runs an import document sent in the request body — a virtual import —
         through the connection, with the API and the integration in the
-        path supplying the execution context — hooks receive `options.settings` with the integration's settings (none when it carries none) plus `_integrationId`, and no flow. A step in a real call of the API gets less: no integration settings and no `_integrationId`.
+        path supplying the execution context — hooks receive `options.settings` with the integration's and the connection's settings (a resource with none contributes no key) plus `_integrationId`, and no flow. A step in a real call of the API gets less: no integration settings and no `_integrationId`.
         Nothing is saved — the document can be an unsaved draft, a modified
         copy, or a saved import as fetched — and the request executes against
         the live destination: a real write, not a dry run; a saved
         `mockResponse` does not substitute. Pipeline and per-record result are
         those of `POST /v1/connections/{_id}/import`, which runs the document
-        with its own settings only. The API must belong to the
+        without integration or flow context. The API must belong to the
         integration, the connection must be registered to it, and the caller
         needs manage access to the account or the integration.
       parameters:
@@ -4329,10 +4338,12 @@ components:
                 `targetConcurrencyLevel`. While true, `targetConcurrencyLevel` is the throughput lever: a
                 `concurrencyLevel` sent in a PUT is ignored, and one sent in a PATCH is stored but the
                 recovery machinery moves it back toward the target. Recovery never runs on `ftp`
-                connections: FTP errors aren't treated as rate limits.
+                connections: FTP errors aren't treated as rate limits. A rate limit hit by a Tool
+                invocation (`POST /v1/tools/{_id}/invoke`) or an export preview
+                (`POST /v1/exports/preview`) leaves the connection's concurrency as it is.
               x-celigo-ai-guidance:
                 - To change throughput while this is true, write `targetConcurrencyLevel`; a `concurrencyLevel` sent in a PUT returns 200 and changes nothing.
-                - Turning it on copies `concurrencyLevel` into `targetConcurrencyLevel`; turning it off unsets the target and leaves `concurrencyLevel` at its current value, which may be below the old target if a recovery was in progress. A `targetConcurrencyLevel` written while this is false is unset by the save.
+                - Turning it on copies `concurrencyLevel` into `targetConcurrencyLevel`; turning it off unsets the target and leaves `concurrencyLevel` at its current value, which may be below the old target if a recovery was in progress. A `targetConcurrencyLevel` sent on a create that sets this false, or with the write that turns this off, is dropped; on a connection where this is already false, writing one fails with 422 `invalid_concurrency_level`.
                 - These four settings (`concurrencyLevel`, `targetConcurrencyLevel`, `_borrowConcurrencyFromConnectionId`, this flag) accept a credential-free `PATCH /v1/connections/{_id}`. A PUT replaces the whole document, so send each secret back as its masked `******` value (that keeps it) or as a new value, and never drop one to keep it — an omitted password or `http.encrypted` is cleared, and a static token left out (with no `refreshMethod`) fails the PUT with 422.
                 - On a create, while this is true, set the level with `targetConcurrencyLevel`: on `http`, `ftp`, `rdbms` and `mongodb` connections the save stores the target sent, or the adaptor's default without one (1 for `ftp`, 5 for `rdbms` and `mongodb`, 25 for `http` where the license's `concurrency` is at least 25), as both fields, whatever `concurrencyLevel` the body carried. A create that sends this as `false` keeps its `concurrencyLevel`.
                 - On an `ftp` connection recovery never runs, and transfer threads are `ftp.multiThreadCount`.
@@ -4969,8 +4980,10 @@ components:
             While `autoRecoverRateLimitErrors` is true, a create sets `concurrencyLevel` to this value, and a
             create that omits it gets 1 for both. Auto-recovery never runs on FTP connections (FTP errors
             aren't treated as rate limits), so nothing climbs back to it.
-            Kept on a `PUT` that omits it, like `concurrencyLevel`; unset by the save while
-            `autoRecoverRateLimitErrors` is false.
+            Kept on a `PUT` that omits it, like `concurrencyLevel`. A create that sends
+            `autoRecoverRateLimitErrors` false, or a write that turns it off, drops it; on a connection
+            where the flag is already false, sending it fails with 422 `invalid_concurrency_level`
+            ("cannot be set when autoRecoverRateLimitErrors is false").
           minimum: 1
           maximum: 50
           examples:
@@ -5711,9 +5724,10 @@ components:
             Higher values increase throughput but may trigger API rate limits.
             Set this based on the target API's rate limit documentation.
             Send no more than the account's licensed maximum (25 standard, 50 with an Environments license).
-            A decimal is rejected with 422 `invalid_field_value` on every write (the same rule applies to every
-            adaptor's `concurrencyLevel` and `targetConcurrencyLevel`, and to `ftp.multiThreadCount`).
-            Platform-managed while `autoRecoverRateLimitErrors` is true — a create or PUT ignores the value (a create without `targetConcurrencyLevel` stores 25 where the license's `concurrency` is at least 25) and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
+            A create, a PATCH, and a PUT while `autoRecoverRateLimitErrors` is false reject a decimal with 422
+            `invalid_field_value` and a boolean or a non-numeric string with 422 `invalid_concurrency_level`
+            ("must be an integer").
+            Platform-managed while `autoRecoverRateLimitErrors` is true — a create still checks the value but stores the target in its place (25 without a `targetConcurrencyLevel`, where the license's `concurrency` is at least 25), a PUT ignores it without checking it, and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
             At level 1 an import's pages run one at a time, so a record's existence lookup and write finish before the next record's start (measured on a single import); the import's `idLockTemplate` serializes only same-key records and leaves the rest parallel.
           minimum: 1
           maximum: 50
@@ -5726,7 +5740,9 @@ components:
             Ceiling the platform climbs back to after rate-limit recovery, in steps of 25% of this value.
             Writing it also sets `concurrencyLevel` to the same value and stops any recovery in progress.
 
-            Honored only while `autoRecoverRateLimitErrors` is true; ignored, and unset, when it is false.
+            Honored only while `autoRecoverRateLimitErrors` is true. A create that sends the flag as false, or a
+            write that turns it off, drops it; on a connection where the flag is already false, sending it fails with 422
+            `invalid_concurrency_level` ("cannot be set when autoRecoverRateLimitErrors is false").
           minimum: 1
           maximum: 50
           examples:
@@ -6497,6 +6513,26 @@ components:
               examples:
                 - - rate_limit_exceeded
                   - too_many_requests
+            failHeaders:
+              type: array
+              description: |
+                Response-header rules for detecting rate limiting, each a header `name` with an
+                optional `value`. A rule with an empty `name` fails the save with 422
+                `invalid_header_format`.
+              items:
+                type: object
+                required:
+                  - name
+                properties:
+                  name:
+                    type: string
+                    description: Response header the rule checks.
+                  value:
+                    type: string
+                    description: Header value the rule checks; omit to check the header alone.
+              examples:
+                - - name: X-RateLimit-Remaining
+                    value: '0'
             limit:
               type: number
               minimum: 1
@@ -9834,7 +9870,8 @@ components:
             connection's traffic counts against the referenced connection's limit instead of its own,
             and its own concurrency and auto-recovery settings have no effect. One level only: the
             referenced connection may not itself borrow, and a connection that others borrow from
-            cannot start borrowing. A connection cannot reference itself (422).
+            cannot start borrowing. Pointing it at the connection itself fails with 422
+            `connection_borrows_from_another`, and an id that matches no connection with 422 `invalid_ref`.
           examples:
             - 615dfa0742763671275b70ab
           x-celigo-ai-guidance:
@@ -9863,6 +9900,8 @@ components:
             such an `http` create that sends only `concurrencyLevel: 10` is stored at 25. To keep the
             `concurrencyLevel` you send, create with this `false`.
             Recovery never runs on `ftp` connections: FTP errors aren't treated as rate limits.
+            A rate limit hit by a Tool invocation (`POST /v1/tools/{_id}/invoke`) or an export preview
+            (`POST /v1/exports/preview`) leaves the connection's concurrency as it is.
         __integrationIds:
           type: array
           maxItems: 100
@@ -10281,8 +10320,9 @@ components:
       type: object
       description: |-
         The outcome of running one input record through an import — one element
-        per record, in input order — shared by `POST /v1/imports/{_id}/invoke`
-        and the virtual import `POST /v1/connections/{_id}/import`. A record the
+        per record, in input order — shared by `POST /v1/imports/{_id}/invoke`,
+        the virtual import `POST /v1/connections/{_id}/import` and its
+        integration-scoped forms. A record the
         import itself ignored before any request carries `ignored: true` and the
         `stage` that dropped it; a record the destination accepted carries its
         parsed response; a record the destination rejected — or that the
@@ -10372,8 +10412,9 @@ components:
           Hooks and templates see the context a real run of the parent gives them: for a flow step,
           `options.settings` carries `import`, `flow` and `integration` with `_flowId` /
           `_integrationId` — identical to the flow's own preview chain; for a tool or an API step it
-          carries `import` and `integration` with `_integrationId` and no flow. A parent or
-          integration with no settings contributes no key at all (no `integration` key when the
+          carries `import` and `integration` with `_integrationId` and no flow. Every form adds
+          `connection` when the connection in the path has settings. A parent, integration or
+          connection with no settings contributes no key at all (no `integration` key when the
           integration carries none).
         - |-
           The connection in the path must be registered to the integration in the path (flows and

package/dist/enduser.yml

@@ -2363,10 +2363,12 @@ components:
                 `targetConcurrencyLevel`. While true, `targetConcurrencyLevel` is the throughput lever: a
                 `concurrencyLevel` sent in a PUT is ignored, and one sent in a PATCH is stored but the
                 recovery machinery moves it back toward the target. Recovery never runs on `ftp`
-                connections: FTP errors aren't treated as rate limits.
+                connections: FTP errors aren't treated as rate limits. A rate limit hit by a Tool
+                invocation (`POST /v1/tools/{_id}/invoke`) or an export preview
+                (`POST /v1/exports/preview`) leaves the connection's concurrency as it is.
               x-celigo-ai-guidance:
                 - To change throughput while this is true, write `targetConcurrencyLevel`; a `concurrencyLevel` sent in a PUT returns 200 and changes nothing.
-                - Turning it on copies `concurrencyLevel` into `targetConcurrencyLevel`; turning it off unsets the target and leaves `concurrencyLevel` at its current value, which may be below the old target if a recovery was in progress. A `targetConcurrencyLevel` written while this is false is unset by the save.
+                - Turning it on copies `concurrencyLevel` into `targetConcurrencyLevel`; turning it off unsets the target and leaves `concurrencyLevel` at its current value, which may be below the old target if a recovery was in progress. A `targetConcurrencyLevel` sent on a create that sets this false, or with the write that turns this off, is dropped; on a connection where this is already false, writing one fails with 422 `invalid_concurrency_level`.
                 - These four settings (`concurrencyLevel`, `targetConcurrencyLevel`, `_borrowConcurrencyFromConnectionId`, this flag) accept a credential-free `PATCH /v1/connections/{_id}`. A PUT replaces the whole document, so send each secret back as its masked `******` value (that keeps it) or as a new value, and never drop one to keep it — an omitted password or `http.encrypted` is cleared, and a static token left out (with no `refreshMethod`) fails the PUT with 422.
                 - On a create, while this is true, set the level with `targetConcurrencyLevel`: on `http`, `ftp`, `rdbms` and `mongodb` connections the save stores the target sent, or the adaptor's default without one (1 for `ftp`, 5 for `rdbms` and `mongodb`, 25 for `http` where the license's `concurrency` is at least 25), as both fields, whatever `concurrencyLevel` the body carried. A create that sends this as `false` keeps its `concurrencyLevel`.
                 - On an `ftp` connection recovery never runs, and transfer threads are `ftp.multiThreadCount`.
@@ -3003,8 +3005,10 @@ components:
             While `autoRecoverRateLimitErrors` is true, a create sets `concurrencyLevel` to this value, and a
             create that omits it gets 1 for both. Auto-recovery never runs on FTP connections (FTP errors
             aren't treated as rate limits), so nothing climbs back to it.
-            Kept on a `PUT` that omits it, like `concurrencyLevel`; unset by the save while
-            `autoRecoverRateLimitErrors` is false.
+            Kept on a `PUT` that omits it, like `concurrencyLevel`. A create that sends
+            `autoRecoverRateLimitErrors` false, or a write that turns it off, drops it; on a connection
+            where the flag is already false, sending it fails with 422 `invalid_concurrency_level`
+            ("cannot be set when autoRecoverRateLimitErrors is false").
           minimum: 1
           maximum: 50
           examples:
@@ -3745,9 +3749,10 @@ components:
             Higher values increase throughput but may trigger API rate limits.
             Set this based on the target API's rate limit documentation.
             Send no more than the account's licensed maximum (25 standard, 50 with an Environments license).
-            A decimal is rejected with 422 `invalid_field_value` on every write (the same rule applies to every
-            adaptor's `concurrencyLevel` and `targetConcurrencyLevel`, and to `ftp.multiThreadCount`).
-            Platform-managed while `autoRecoverRateLimitErrors` is true — a create or PUT ignores the value (a create without `targetConcurrencyLevel` stores 25 where the license's `concurrency` is at least 25) and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
+            A create, a PATCH, and a PUT while `autoRecoverRateLimitErrors` is false reject a decimal with 422
+            `invalid_field_value` and a boolean or a non-numeric string with 422 `invalid_concurrency_level`
+            ("must be an integer").
+            Platform-managed while `autoRecoverRateLimitErrors` is true — a create still checks the value but stores the target in its place (25 without a `targetConcurrencyLevel`, where the license's `concurrency` is at least 25), a PUT ignores it without checking it, and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
             At level 1 an import's pages run one at a time, so a record's existence lookup and write finish before the next record's start (measured on a single import); the import's `idLockTemplate` serializes only same-key records and leaves the rest parallel.
           minimum: 1
           maximum: 50
@@ -3760,7 +3765,9 @@ components:
             Ceiling the platform climbs back to after rate-limit recovery, in steps of 25% of this value.
             Writing it also sets `concurrencyLevel` to the same value and stops any recovery in progress.
 
-            Honored only while `autoRecoverRateLimitErrors` is true; ignored, and unset, when it is false.
+            Honored only while `autoRecoverRateLimitErrors` is true. A create that sends the flag as false, or a
+            write that turns it off, drops it; on a connection where the flag is already false, sending it fails with 422
+            `invalid_concurrency_level` ("cannot be set when autoRecoverRateLimitErrors is false").
           minimum: 1
           maximum: 50
           examples:
@@ -4531,6 +4538,26 @@ components:
               examples:
                 - - rate_limit_exceeded
                   - too_many_requests
+            failHeaders:
+              type: array
+              description: |
+                Response-header rules for detecting rate limiting, each a header `name` with an
+                optional `value`. A rule with an empty `name` fails the save with 422
+                `invalid_header_format`.
+              items:
+                type: object
+                required:
+                  - name
+                properties:
+                  name:
+                    type: string
+                    description: Response header the rule checks.
+                  value:
+                    type: string
+                    description: Header value the rule checks; omit to check the header alone.
+              examples:
+                - - name: X-RateLimit-Remaining
+                    value: '0'
             limit:
               type: number
               minimum: 1

package/dist/export.yml

@@ -1661,6 +1661,21 @@ components:
             - shopify
             - stripe
             - custom
+        formType:
+          type: string
+          enum:
+            - simple
+            - webhook
+          x-enumDescriptions:
+            simple: Simple form, the default for a named provider (e.g. `shopify`, `stripe`).
+            webhook: Full webhook form, the default when `provider` is `custom` or omitted.
+          description: |-
+            Which webhook export form the UI uses to edit this listener. A value sent on create or
+            update wins (case-insensitive — `Simple` is stored as `simple`); a PUT that omits it
+            keeps the stored value, and a new export without one gets the default for its
+            `provider`. Every webhook export GET carries it.
+          examples:
+            - webhook
         verify:
           type: string
           x-celigo-ui-override: Required by the webhook export form (verify is required:true). Encoded to mirror the form so builders produce connectable configurations.
@@ -5958,6 +5973,8 @@ components:
           A stream export that resolves no snapshot mode — neither `snapshotMode` nor a
           `snapshot.mode` entry in `properties` — is rejected 422 ("Expected field: snapshotMode
           to be present").
+      required:
+        - paths
       properties:
         captureMode:
           type: string
@@ -6067,13 +6084,13 @@ components:
             - Never author or modify this field — the platform owns the stream position.
         paths:
           type: array
+          minItems: 1
           items:
             type: string
           description: |-
-            Dot-notation paths within each raw change event to retain in the emitted record. MongoDB
-            listeners default to `["payload"]` (the whole change document); SQL Server, PostgreSQL and
-            MySQL listeners commonly select `payload.after`, `payload.op`, and related fields to expose
-            the changed row and operation type. The MySQL listener form offers `payload.after`,
+            Dot-notation paths within each raw change event to retain in the emitted record, such as
+            `payload.after` (the changed row or document) and `payload.op` (the operation type).
+            The MySQL listener form offers `payload.after`,
             `payload.before`, `schema`, `payload.source`, `payload.op`, `payload.transaction`,
             `payload.ts_ms`, `payload.ts_us` and `payload.ts_ns`, preselecting `payload.after`; it has
             no `updateDescription`-derived options and no `payload.id`. The MySQL listener
@@ -6081,8 +6098,9 @@ components:
             as the row before an update or delete (needs `binlog_row_image=FULL`), `op` as `c` / `u` /
             `d` / `r` (insert / update / delete / snapshot read) and `source` as the database, table,
             binlog file and position.
+          x-celigo-ui-override: 'Required by every listener form (MongoDB, SQL Server, PostgreSQL, and MySQL: cdc.paths is a required:true multiselect with defaultValue [''payload.after'']). Encoded here to mirror the forms so builders produce complete listener configurations.'
           examples:
-            - - payload
+            - - payload.after
             - - payload.after
               - payload.op
             - - payload.after
@@ -6110,7 +6128,9 @@ components:
             serialized first, followed by optional keys such as `field.exclude.list`,
             `column.include.list`, or `snapshot.collection.filter.overrides.<db>.<collection>`.
             On save the API also lifts `snapshot.mode` / `capture.mode` entries into the typed
-            `snapshotMode` / `captureMode` fields.
+            `snapshotMode` / `captureMode` fields. When one body carries both with different values,
+            the `snapshot.mode` entry wins on SQL Server, PostgreSQL and MySQL listeners, and the typed
+            `snapshotMode` wins on a MongoDB listener.
 
             The MySQL listener form offers six keys: `snapshot.mode` (preselected `no_data`) and five
             optional comma-separated regular-expression lists — `table.exclude.list` (matched on
@@ -6125,6 +6145,11 @@ components:
               The API persists any key sent here without validating it against the connector, so a
               MongoDB or PostgreSQL key on a MySQL listener saves cleanly and does nothing — author only
               the keys the listener's form offers.
+            - |-
+              On SQL Server, PostgreSQL, and MySQL listeners every save appends one more
+              `snapshot.mode` entry that repeats the resolved mode, so a GET response lists it twice
+              and each GET-then-PUT round trip adds another copy. Send a single `snapshot.mode`
+              entry: drop the trailing repeats before you PUT a fetched export back.
           items:
             type: object
             required:
@@ -12111,7 +12136,7 @@ components:
         {
           "type": "stream",
           "rdbms": { "tables": "public.orders,public.customers" },
-          "cdc": { "properties": [{ "name": "snapshot.mode", "value": "no_data" }] }
+          "cdc": { "properties": [{ "name": "snapshot.mode", "value": "no_data" }], "paths": ["payload.after"] }
         }
         ```
         A MySQL listener names its tables as `database.table` (MySQL has no schema layer):
@@ -16754,7 +16779,9 @@ components:
               `stream` is accepted only on MongoDB and RDBMS exports (SQL Server,
               PostgreSQL or MySQL connections) and on Event Streams listeners
               (`adaptorType: TopicExport`); every other adaptor rejects the save
-              with `unsupported_export_type`. A MongoDB or RDBMS stream export
+              with `unsupported_export_type`, and a MariaDB connection is rejected
+              with 422 `missing_required_field` on `type` ("RDBMS stream export not
+              supported for mariadb"). A MongoDB or RDBMS stream export
               must carry `cdc.snapshotMode` (and `cdc.captureMode` on MongoDB) —
               omitting them fails with 422 `missing_required_field` on those paths.
           enum:

package/dist/import.yml

@@ -8567,9 +8567,23 @@ components:
           description: |-
             Tool resource this import executes. The tool supplies the input schema, routing, page
             processors, and output mapping; the import runs that tool when records reach it. Required —
-            a `ToolImport` has no behavior without a tool to run.
+            a `ToolImport` has no behavior without a tool to run. Saving the import fails with 422 when the
+            tool has no routers, a step still being set up, or a branch that does not merge back; the
+            message names the tool.
           x-celigo-ai-guidance:
             - Reference to the Celigo Tool resource this wrapper invokes.
+            - |-
+              Finish the tool before saving its wrapper: a create or update of this import fails with 422
+              tool_empty_router when the tool has no `routers` (missing or empty; the message reads "…has
+              no steps. Add at least one step to the tool, then save again."), router_setup_in_progress
+              when a step is still being set up (setupInProgress), and tool_dangling_branch when a branch
+              has no nextRouterId ("outputRouter" ends the tool). Fix the tool with PUT /v1/tools/{_id},
+              then save the import again.
+            - |-
+              A save that passes doesn't mean the tool runs: a branch with empty `pageProcessors` passes
+              it, and the tool then fails at invoke with 400 tool_empty_router. Creating a parent tool, or
+              a disabled flow, whose step is this wrapper is not checked either: both saved while the
+              wrapped tool had no routers.
             - |-
               Required.
               The Tool must already exist;
@@ -8973,16 +8987,20 @@ components:
               The `key` + `batchSize` combination has not been probed (it needs a B2B Manager
               account) — treat it as unverified, neither allowed nor forbidden.
         encrypt:
-          type: boolean
+          type: string
+          enum:
+            - pgp
+          x-enumDescriptions:
+            pgp: Encrypt the file with PGP before it is written.
           description: |-
-            Whether to encrypt the output file.
-
-            **Values**
-            - `true`: Encrypt the file (requires PGP configuration)
-            - `false`: No encryption
-
-            **Default:** `false`
-          default: false
+            Encrypts the output file; omit it for an unencrypted file. `pgp` requires
+            `pgp.symmetricKeyAlgorithm` and a connection holding the recipient's public key
+            (`pgp.publicKey`) — without either the save fails with 422 `missing_required_field`.
+            The public-key check runs first: on a connection without one, any `encrypt` value,
+            `false` included, fails with 422 `missing_required_field` "pgp publicKey is required
+            when encrypt is selected to perform file encryption." before the value is checked.
+            Blob (file-transfer) imports follow the same rule and return `encrypt` and `pgp` even
+            without `file.type`.
         csv:
           type: object
           description: CSV-specific configuration. Only used when `type` is `"csv"`.
@@ -9149,8 +9167,8 @@ components:
         pgp:
           type: object
           description: |-
-            PGP encryption settings applied when encrypt is true; selects the symmetric cipher and the
-            signing hash. The connection must hold the recipient's public key.
+            PGP encryption settings applied when `encrypt` is `pgp`; selects the symmetric cipher and
+            the signing hash. The connection must hold the recipient's public key.
           properties:
             symmetricKeyAlgorithm:
               type: string
@@ -9167,9 +9185,10 @@ components:
                 3des: Triple DES block cipher (legacy).
                 aes128: AES with a 128-bit key.
                 aes192: AES with a 192-bit key.
-                aes256: AES with a 256-bit key (default, recommended).
-              default: aes256
-              description: Symmetric cipher used to encrypt the file body; aes256 unless the recipient requires another.
+                aes256: AES with a 256-bit key (recommended).
+              description: |-
+                Symmetric cipher used to encrypt the file body; required when `encrypt` is `pgp` (no
+                server default). Use aes256 unless the recipient requires another.
               examples:
                 - aes256
                 - 3des
@@ -18086,8 +18105,9 @@ components:
       type: object
       description: |-
         The outcome of running one input record through an import — one element
-        per record, in input order — shared by `POST /v1/imports/{_id}/invoke`
-        and the virtual import `POST /v1/connections/{_id}/import`. A record the
+        per record, in input order — shared by `POST /v1/imports/{_id}/invoke`,
+        the virtual import `POST /v1/connections/{_id}/import` and its
+        integration-scoped forms. A record the
         import itself ignored before any request carries `ignored: true` and the
         `stage` that dropped it; a record the destination accepted carries its
         parsed response; a record the destination rejected — or that the