@celigo/api-specs 0.2.175 → 0.2.176

package/dist/api.yml

@@ -5460,7 +5460,8 @@ components:
                 - 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.
                 - 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 an `ftp` connection recovery never runs, and transfer threads are `ftp.multiThreadCount`; while this is true a create sets `ftp.concurrencyLevel` to `ftp.targetConcurrencyLevel`, or to 1 without one.
+                - 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`.
             enableMicroBatchForOneToMany:
               type: boolean
               default: true
@@ -6827,7 +6828,7 @@ components:
             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 PUT ignores the value and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
+            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.
             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

package/dist/connection.yml

@@ -721,6 +721,12 @@ paths:
           in clear on create and come back masked as "******"; the response also carries the
           server-populated fields (`connectionRole: standard`, `concurrencyLevel`,
           `targetConcurrencyLevel`, `microServices`).
+        - |-
+          Choose the level with `targetConcurrencyLevel`, or send `autoRecoverRateLimitErrors: false`
+          with `concurrencyLevel`. While auto-recovery is on, which a create gets unless it sends
+          `false`, an `http`, `ftp`, `rdbms` or `mongodb` create replaces a `concurrencyLevel` sent
+          without a target with the adaptor's default, so an `http` create that asks for 10 is stored at
+          25 where the license's `concurrency` is at least 25 (see `autoRecoverRateLimitErrors`).
   /v1/connections/{_id}:
     get:
       x-internal: false
@@ -4311,7 +4317,8 @@ components:
                 - 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.
                 - 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 an `ftp` connection recovery never runs, and transfer threads are `ftp.multiThreadCount`; while this is true a create sets `ftp.concurrencyLevel` to `ftp.targetConcurrencyLevel`, or to 1 without one.
+                - 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`.
             enableMicroBatchForOneToMany:
               type: boolean
               default: true
@@ -5678,7 +5685,7 @@ components:
             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 PUT ignores the value and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
+            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.
             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
@@ -9663,6 +9670,13 @@ components:
             drops to 1 and climbs back toward the adaptor block's `targetConcurrencyLevel`, which is the
             throughput lever while this is on. Turning it on copies the current `concurrencyLevel` into
             the target; turning it off unsets the target and leaves `concurrencyLevel` at its current value.
+            A create gets `true` unless it sends `false`; while it is true, set a new connection's level
+            with `targetConcurrencyLevel`. On `http`, `ftp`, `rdbms` and `mongodb` connections the create
+            stores the target sent, or the adaptor's default without one, as both `concurrencyLevel` and
+            `targetConcurrencyLevel`, whatever `concurrencyLevel` the body carried: 1 for `ftp`, 5 for
+            `rdbms` and `mongodb`, and 25 for `http` where the license's `concurrency` is at least 25, so
+            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.
         __integrationIds:
           type: array

package/dist/enduser.yml

@@ -2368,7 +2368,8 @@ components:
                 - 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.
                 - 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 an `ftp` connection recovery never runs, and transfer threads are `ftp.multiThreadCount`; while this is true a create sets `ftp.concurrencyLevel` to `ftp.targetConcurrencyLevel`, or to 1 without one.
+                - 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`.
             enableMicroBatchForOneToMany:
               type: boolean
               default: true
@@ -3735,7 +3736,7 @@ components:
             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 PUT ignores the value and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
+            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.
             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

package/dist/mcp-server.yml

@@ -4204,7 +4204,8 @@ components:
                 - 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.
                 - 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 an `ftp` connection recovery never runs, and transfer threads are `ftp.multiThreadCount`; while this is true a create sets `ftp.concurrencyLevel` to `ftp.targetConcurrencyLevel`, or to 1 without one.
+                - 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`.
             enableMicroBatchForOneToMany:
               type: boolean
               default: true
@@ -5571,7 +5572,7 @@ components:
             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 PUT ignores the value and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
+            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.
             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

package/dist/tool.yml

@@ -7738,7 +7738,8 @@ components:
                 - 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.
                 - 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 an `ftp` connection recovery never runs, and transfer threads are `ftp.multiThreadCount`; while this is true a create sets `ftp.concurrencyLevel` to `ftp.targetConcurrencyLevel`, or to 1 without one.
+                - 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`.
             enableMicroBatchForOneToMany:
               type: boolean
               default: true
@@ -9105,7 +9106,7 @@ components:
             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 PUT ignores the value and the recovery machinery moves it toward the target; set `targetConcurrencyLevel` instead.
+            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.
             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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celigo/api-specs",
-  "version": "0.2.175",
+  "version": "0.2.176",
   "private": false,
   "description": "Public OpenAPI bundles (dist/) and the celigo-cli lint schema pack (schemas.json).",
   "keywords": [

package/schemas.json

@@ -1,7 +1,7 @@
 {
 	"provenance": {
 		"repo": "celigo/integrator-api-specs",
-		"iasCommit": "89a6949a",
+		"iasCommit": "06b10943",
 		"generatedAt": "2026-10-22"
 	},
 	"roots": {