@celigo/api-specs 0.2.206 → 0.2.208

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
@@ -11301,9 +11328,21 @@ components:
                 - COMPUTE_WH
             schema:
               type: string
-              description: |
-                Default Snowflake schema. If omitted, queries must fully-qualify table names
-                (e.g., DATABASE.SCHEMA.TABLE).
+              description: |-
+                Default schema for the session: unqualified table names in queries resolve here, and
+                optimized bulk load imports create their temporary staging table here even when the
+                destination table is schema-qualified — so the connection's role must be able to
+                create that table in it. When blank, optimized bulk load uses PUBLIC.
+              x-celigo-ai-guidance:
+                - |-
+                  When this names a schema the session cannot resolve — Snowflake reports it as not
+                  existing or not authorized for the role, and the session is left without a current
+                  schema — every optimized bulk load fails at the staging step with code `query_fail`
+                  and the message "Failed to run the bulk load query. Err: [TempTableQuery] The
+                  provided schema is invalid: <this value>" (the connector's rewrite of Snowflake's
+                  "This session does not have a current schema"). Fix: set this to a schema the role
+                  can create the staging table in — normally the destination table's own schema — or
+                  point the import at a second Snowflake connection with that default schema.
               examples:
                 - PUBLIC
             role:

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
@@ -7125,9 +7161,21 @@ components:
                 - COMPUTE_WH
             schema:
               type: string
-              description: |
-                Default Snowflake schema. If omitted, queries must fully-qualify table names
-                (e.g., DATABASE.SCHEMA.TABLE).
+              description: |-
+                Default schema for the session: unqualified table names in queries resolve here, and
+                optimized bulk load imports create their temporary staging table here even when the
+                destination table is schema-qualified — so the connection's role must be able to
+                create that table in it. When blank, optimized bulk load uses PUBLIC.
+              x-celigo-ai-guidance:
+                - |-
+                  When this names a schema the session cannot resolve — Snowflake reports it as not
+                  existing or not authorized for the role, and the session is left without a current
+                  schema — every optimized bulk load fails at the staging step with code `query_fail`
+                  and the message "Failed to run the bulk load query. Err: [TempTableQuery] The
+                  provided schema is invalid: <this value>" (the connector's rewrite of Snowflake's
+                  "This session does not have a current schema"). Fix: set this to a schema the role
+                  can create the staging table in — normally the destination table's own schema — or
+                  point the import at a second Snowflake connection with that default schema.
               examples:
                 - PUBLIC
             role:
@@ -9834,7 +9882,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 +9912,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 +10332,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 +10424,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
@@ -5159,9 +5186,21 @@ components:
                 - COMPUTE_WH
             schema:
               type: string
-              description: |
-                Default Snowflake schema. If omitted, queries must fully-qualify table names
-                (e.g., DATABASE.SCHEMA.TABLE).
+              description: |-
+                Default schema for the session: unqualified table names in queries resolve here, and
+                optimized bulk load imports create their temporary staging table here even when the
+                destination table is schema-qualified — so the connection's role must be able to
+                create that table in it. When blank, optimized bulk load uses PUBLIC.
+              x-celigo-ai-guidance:
+                - |-
+                  When this names a schema the session cannot resolve — Snowflake reports it as not
+                  existing or not authorized for the role, and the session is left without a current
+                  schema — every optimized bulk load fails at the staging step with code `query_fail`
+                  and the message "Failed to run the bulk load query. Err: [TempTableQuery] The
+                  provided schema is invalid: <this value>" (the connector's rewrite of Snowflake's
+                  "This session does not have a current schema"). Fix: set this to a schema the role
+                  can create the staging table in — normally the destination table's own schema — or
+                  point the import at a second Snowflake connection with that default schema.
               examples:
                 - PUBLIC
             role: