@celigo/api-specs 0.2.151 → 0.2.153

package/dist/ai-agent.yml

@@ -2410,6 +2410,12 @@ components:
             - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
               '$[*].Tax' (every row of a grouped record)
             - Wildcards like [*] extract multiple values/objects
+            - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+              `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+              path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+              need no brackets (`$.Ship To Name`, `$.Tracking #`)
+            - Filter expressions such as `$.items[?(@.active)]` fail the record with
+              "Eval [?(expr)] prevented in JSONPath expression."
 
             ```json
             "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -2598,6 +2604,12 @@ components:
             **Usage**
 
             The lookupName refers to a named lookup defined in the lookups array of the same resource.
+            On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+            is dropped on save. On an import, a name that matches no lookup fails every record
+            with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+            doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+            the field left out, lets the record succeed with the lookup's `default`, or without
+            the mapped field when there is none.
 
             ```json
             {
@@ -2935,6 +2947,11 @@ components:
                   The system creates special composite objects during processing to maintain
                   hierarchical relationships, allowing easy access to both the current array item
                   and its parent contexts.
+
+                  An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                  element per item, with no error. Child extracts drop the `[*]` but keep the
+                  array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                  element-relative `$.sku` reads the record root instead of the element.
                 examples:
                   - $.items[*]
                   - $.order.lineItems[*]
@@ -3146,14 +3163,17 @@ components:
           type: string
           description: |
             **Purpose**
-            Required on every mapping entry. Controls whether the mapping is applied.
+            Controls whether the mapping is applied. Send it on every mapping entry.
 
             **Guidance**
             Only `Active` rows run. `Draft` and `Inactive` rows keep their
             configuration, are saved with minimal validation, and are skipped at
             runtime and in preview; a non-Active parent skips its whole subtree
-            whatever its children say. The API rejects a mapping missing this field
-            (validation error: "Mapping object must have status field present.").
+            whatever its children say. Imports (on save and in the mapper processor)
+            and API response mappings reject a row missing this field (validation
+            error: "Mapping object must have status field present."); a Tool's
+            output mapping saves and runs one, which is why `required` doesn't
+            list it.
           x-celigo-ai-guidance:
             - |-
               Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -3476,6 +3496,12 @@ components:
               - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
                 '$[*].Tax' (every row of a grouped record)
               - Wildcards like [*] extract multiple values/objects
+              - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+                `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+                path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+                need no brackets (`$.Ship To Name`, `$.Tracking #`)
+              - Filter expressions such as `$.items[?(@.active)]` fail the record with
+                "Eval [?(expr)] prevented in JSONPath expression."
 
               ```json
               "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -3664,6 +3690,12 @@ components:
               **Usage**
 
               The lookupName refers to a named lookup defined in the lookups array of the same resource.
+              On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+              is dropped on save. On an import, a name that matches no lookup fails every record
+              with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+              doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+              the field left out, lets the record succeed with the lookup's `default`, or without
+              the mapped field when there is none.
 
               ```json
               {
@@ -4001,6 +4033,11 @@ components:
                     The system creates special composite objects during processing to maintain
                     hierarchical relationships, allowing easy access to both the current array item
                     and its parent contexts.
+
+                    An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                    element per item, with no error. Child extracts drop the `[*]` but keep the
+                    array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                    element-relative `$.sku` reads the record root instead of the element.
                   examples:
                     - $.items[*]
                     - $.order.lineItems[*]
@@ -4212,14 +4249,17 @@ components:
             type: string
             description: |
               **Purpose**
-              Required on every mapping entry. Controls whether the mapping is applied.
+              Controls whether the mapping is applied. Send it on every mapping entry.
 
               **Guidance**
               Only `Active` rows run. `Draft` and `Inactive` rows keep their
               configuration, are saved with minimal validation, and are skipped at
               runtime and in preview; a non-Active parent skips its whole subtree
-              whatever its children say. The API rejects a mapping missing this field
-              (validation error: "Mapping object must have status field present.").
+              whatever its children say. Imports (on save and in the mapper processor)
+              and API response mappings reject a row missing this field (validation
+              error: "Mapping object must have status field present."); a Tool's
+              output mapping saves and runs one, which is why `required` doesn't
+              list it.
             x-celigo-ai-guidance:
               - |-
                 Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -5213,8 +5253,8 @@ components:
               - Original value indicators: "{Original Value}", "No mapping found"
               - Neutral values: "Other", "N/A", "Miscellaneous"
 
-              If allowFailures is false and no default is specified, the flow will fail
-              when encountering unmapped values.
+              If allowFailures is false, a record whose value is unmapped fails and the default
+              is ignored.
             examples:
               - Unknown
               - Other
@@ -5235,7 +5275,11 @@ components:
               This field determines how the system handles source values that don't exist in the map:
 
               - true: Use the default value for missing mappings and continue processing
-              - false: Treat missing mappings as errors, failing the record
+              - false: Treat missing mappings as errors, failing the record (`lookup_error` for a
+                static map, `lookupcache_evaluation_failed` for a lookup cache)
+              - omitted or null: the record doesn't fail either. On an import a static lookup writes
+                its default if it has one, and a static or cache lookup without one leaves the
+                mapped field out of the output, with no error
 
               **Recommendation**
 
@@ -5249,11 +5293,14 @@ components:
               - All possible source values are known and controlled
               - Missing mappings indicate serious data problems that should be addressed
 
-              The best practice is typically to set allowFailures to true with a meaningful
-              default value, so flows remain operational while alerting you to missing mappings.
+              A default raises no error: records that miss go out with the default value and
+              nothing reports them. Use true only when that fallback is acceptable at the
+              destination, and set false explicitly when a missing value must stop the record.
             examples:
               - true
               - false
+            x-celigo-ai-guidance:
+              - 'Never leave this field out to mean "fail on a miss": on an import, an omitted or null value lets a missing key through without an error (with the default, or without the mapped field when there is none). Only an explicit false fails the record.'
     Transform:
       type: object
       description: |

package/dist/asynchelper.yml

@@ -619,6 +619,12 @@ components:
             - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
               '$[*].Tax' (every row of a grouped record)
             - Wildcards like [*] extract multiple values/objects
+            - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+              `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+              path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+              need no brackets (`$.Ship To Name`, `$.Tracking #`)
+            - Filter expressions such as `$.items[?(@.active)]` fail the record with
+              "Eval [?(expr)] prevented in JSONPath expression."
 
             ```json
             "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -807,6 +813,12 @@ components:
             **Usage**
 
             The lookupName refers to a named lookup defined in the lookups array of the same resource.
+            On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+            is dropped on save. On an import, a name that matches no lookup fails every record
+            with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+            doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+            the field left out, lets the record succeed with the lookup's `default`, or without
+            the mapped field when there is none.
 
             ```json
             {
@@ -1144,6 +1156,11 @@ components:
                   The system creates special composite objects during processing to maintain
                   hierarchical relationships, allowing easy access to both the current array item
                   and its parent contexts.
+
+                  An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                  element per item, with no error. Child extracts drop the `[*]` but keep the
+                  array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                  element-relative `$.sku` reads the record root instead of the element.
                 examples:
                   - $.items[*]
                   - $.order.lineItems[*]
@@ -1355,14 +1372,17 @@ components:
           type: string
           description: |
             **Purpose**
-            Required on every mapping entry. Controls whether the mapping is applied.
+            Controls whether the mapping is applied. Send it on every mapping entry.
 
             **Guidance**
             Only `Active` rows run. `Draft` and `Inactive` rows keep their
             configuration, are saved with minimal validation, and are skipped at
             runtime and in preview; a non-Active parent skips its whole subtree
-            whatever its children say. The API rejects a mapping missing this field
-            (validation error: "Mapping object must have status field present.").
+            whatever its children say. Imports (on save and in the mapper processor)
+            and API response mappings reject a row missing this field (validation
+            error: "Mapping object must have status field present."); a Tool's
+            output mapping saves and runs one, which is why `required` doesn't
+            list it.
           x-celigo-ai-guidance:
             - |-
               Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -1685,6 +1705,12 @@ components:
               - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
                 '$[*].Tax' (every row of a grouped record)
               - Wildcards like [*] extract multiple values/objects
+              - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+                `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+                path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+                need no brackets (`$.Ship To Name`, `$.Tracking #`)
+              - Filter expressions such as `$.items[?(@.active)]` fail the record with
+                "Eval [?(expr)] prevented in JSONPath expression."
 
               ```json
               "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -1873,6 +1899,12 @@ components:
               **Usage**
 
               The lookupName refers to a named lookup defined in the lookups array of the same resource.
+              On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+              is dropped on save. On an import, a name that matches no lookup fails every record
+              with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+              doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+              the field left out, lets the record succeed with the lookup's `default`, or without
+              the mapped field when there is none.
 
               ```json
               {
@@ -2210,6 +2242,11 @@ components:
                     The system creates special composite objects during processing to maintain
                     hierarchical relationships, allowing easy access to both the current array item
                     and its parent contexts.
+
+                    An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                    element per item, with no error. Child extracts drop the `[*]` but keep the
+                    array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                    element-relative `$.sku` reads the record root instead of the element.
                   examples:
                     - $.items[*]
                     - $.order.lineItems[*]
@@ -2421,14 +2458,17 @@ components:
             type: string
             description: |
               **Purpose**
-              Required on every mapping entry. Controls whether the mapping is applied.
+              Controls whether the mapping is applied. Send it on every mapping entry.
 
               **Guidance**
               Only `Active` rows run. `Draft` and `Inactive` rows keep their
               configuration, are saved with minimal validation, and are skipped at
               runtime and in preview; a non-Active parent skips its whole subtree
-              whatever its children say. The API rejects a mapping missing this field
-              (validation error: "Mapping object must have status field present.").
+              whatever its children say. Imports (on save and in the mapper processor)
+              and API response mappings reject a row missing this field (validation
+              error: "Mapping object must have status field present."); a Tool's
+              output mapping saves and runs one, which is why `required` doesn't
+              list it.
             x-celigo-ai-guidance:
               - |-
                 Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -2799,8 +2839,8 @@ components:
               - Original value indicators: "{Original Value}", "No mapping found"
               - Neutral values: "Other", "N/A", "Miscellaneous"
 
-              If allowFailures is false and no default is specified, the flow will fail
-              when encountering unmapped values.
+              If allowFailures is false, a record whose value is unmapped fails and the default
+              is ignored.
             examples:
               - Unknown
               - Other
@@ -2821,7 +2861,11 @@ components:
               This field determines how the system handles source values that don't exist in the map:
 
               - true: Use the default value for missing mappings and continue processing
-              - false: Treat missing mappings as errors, failing the record
+              - false: Treat missing mappings as errors, failing the record (`lookup_error` for a
+                static map, `lookupcache_evaluation_failed` for a lookup cache)
+              - omitted or null: the record doesn't fail either. On an import a static lookup writes
+                its default if it has one, and a static or cache lookup without one leaves the
+                mapped field out of the output, with no error
 
               **Recommendation**
 
@@ -2835,11 +2879,14 @@ components:
               - All possible source values are known and controlled
               - Missing mappings indicate serious data problems that should be addressed
 
-              The best practice is typically to set allowFailures to true with a meaningful
-              default value, so flows remain operational while alerting you to missing mappings.
+              A default raises no error: records that miss go out with the default value and
+              nothing reports them. Use true only when that fallback is acceptable at the
+              destination, and set false explicitly when a missing value must stop the record.
             examples:
               - true
               - false
+            x-celigo-ai-guidance:
+              - 'Never leave this field out to mean "fail on a miss": on an import, an omitted or null value lets a missing key through without an error (with the default, or without the mapped field when there is none). Only an explicit false fails the record.'
     Transform:
       type: object
       description: |

package/dist/export.yml

@@ -6615,6 +6615,8 @@ components:
             Controls how the export requests subsequent pages when the API returns multi-page responses. The `method` field determines which companion fields are required and how each next page is requested. For the page, skip, and token methods, reference the matching pagination variable (`{{export.http.paging.page}}`, `{{export.http.paging.skip}}`, or `{{export.http.paging.token}}`) in the relative URI or request body — misconfigured pagination is a common cause of incomplete data retrieval.
 
             When this export is the first lookup of a builder-mode API with `pagination.enabled` set, it is that API's volume driver: saving the export (even unchanged) invalidates the API's issued cursors, so a caller mid-walk gets an empty final page, and removing `paging` is accepted on save but makes every call to the API fail with `400 api_pagination_source_not_paged` until paging is restored or the API's flag is turned off.
+
+            When a next page's response is identical to the previous one, paging stops: the export records an open error with code `page_response_error` ("Identical response received from next page request. No more page requests will be made.") and the run completes with the pages already read, so later pages are never exported. A request that doesn't change between pages produces this, as observed with `method: page` and the pagination variable missing from the relative URI and body; reference the variable so each request asks for the next page.
           x-celigo-ai-guidance:
             - Configuration object for navigating through multi-page API responses.
             - |-
@@ -12516,6 +12518,12 @@ components:
             - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
               '$[*].Tax' (every row of a grouped record)
             - Wildcards like [*] extract multiple values/objects
+            - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+              `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+              path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+              need no brackets (`$.Ship To Name`, `$.Tracking #`)
+            - Filter expressions such as `$.items[?(@.active)]` fail the record with
+              "Eval [?(expr)] prevented in JSONPath expression."
 
             ```json
             "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -12704,6 +12712,12 @@ components:
             **Usage**
 
             The lookupName refers to a named lookup defined in the lookups array of the same resource.
+            On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+            is dropped on save. On an import, a name that matches no lookup fails every record
+            with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+            doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+            the field left out, lets the record succeed with the lookup's `default`, or without
+            the mapped field when there is none.
 
             ```json
             {
@@ -13041,6 +13055,11 @@ components:
                   The system creates special composite objects during processing to maintain
                   hierarchical relationships, allowing easy access to both the current array item
                   and its parent contexts.
+
+                  An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                  element per item, with no error. Child extracts drop the `[*]` but keep the
+                  array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                  element-relative `$.sku` reads the record root instead of the element.
                 examples:
                   - $.items[*]
                   - $.order.lineItems[*]
@@ -13252,14 +13271,17 @@ components:
           type: string
           description: |
             **Purpose**
-            Required on every mapping entry. Controls whether the mapping is applied.
+            Controls whether the mapping is applied. Send it on every mapping entry.
 
             **Guidance**
             Only `Active` rows run. `Draft` and `Inactive` rows keep their
             configuration, are saved with minimal validation, and are skipped at
             runtime and in preview; a non-Active parent skips its whole subtree
-            whatever its children say. The API rejects a mapping missing this field
-            (validation error: "Mapping object must have status field present.").
+            whatever its children say. Imports (on save and in the mapper processor)
+            and API response mappings reject a row missing this field (validation
+            error: "Mapping object must have status field present."); a Tool's
+            output mapping saves and runs one, which is why `required` doesn't
+            list it.
           x-celigo-ai-guidance:
             - |-
               Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -13582,6 +13604,12 @@ components:
               - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
                 '$[*].Tax' (every row of a grouped record)
               - Wildcards like [*] extract multiple values/objects
+              - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+                `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+                path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+                need no brackets (`$.Ship To Name`, `$.Tracking #`)
+              - Filter expressions such as `$.items[?(@.active)]` fail the record with
+                "Eval [?(expr)] prevented in JSONPath expression."
 
               ```json
               "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -13770,6 +13798,12 @@ components:
               **Usage**
 
               The lookupName refers to a named lookup defined in the lookups array of the same resource.
+              On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+              is dropped on save. On an import, a name that matches no lookup fails every record
+              with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+              doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+              the field left out, lets the record succeed with the lookup's `default`, or without
+              the mapped field when there is none.
 
               ```json
               {
@@ -14107,6 +14141,11 @@ components:
                     The system creates special composite objects during processing to maintain
                     hierarchical relationships, allowing easy access to both the current array item
                     and its parent contexts.
+
+                    An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                    element per item, with no error. Child extracts drop the `[*]` but keep the
+                    array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                    element-relative `$.sku` reads the record root instead of the element.
                   examples:
                     - $.items[*]
                     - $.order.lineItems[*]
@@ -14318,14 +14357,17 @@ components:
             type: string
             description: |
               **Purpose**
-              Required on every mapping entry. Controls whether the mapping is applied.
+              Controls whether the mapping is applied. Send it on every mapping entry.
 
               **Guidance**
               Only `Active` rows run. `Draft` and `Inactive` rows keep their
               configuration, are saved with minimal validation, and are skipped at
               runtime and in preview; a non-Active parent skips its whole subtree
-              whatever its children say. The API rejects a mapping missing this field
-              (validation error: "Mapping object must have status field present.").
+              whatever its children say. Imports (on save and in the mapper processor)
+              and API response mappings reject a row missing this field (validation
+              error: "Mapping object must have status field present."); a Tool's
+              output mapping saves and runs one, which is why `required` doesn't
+              list it.
             x-celigo-ai-guidance:
               - |-
                 Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -14696,8 +14738,8 @@ components:
               - Original value indicators: "{Original Value}", "No mapping found"
               - Neutral values: "Other", "N/A", "Miscellaneous"
 
-              If allowFailures is false and no default is specified, the flow will fail
-              when encountering unmapped values.
+              If allowFailures is false, a record whose value is unmapped fails and the default
+              is ignored.
             examples:
               - Unknown
               - Other
@@ -14718,7 +14760,11 @@ components:
               This field determines how the system handles source values that don't exist in the map:
 
               - true: Use the default value for missing mappings and continue processing
-              - false: Treat missing mappings as errors, failing the record
+              - false: Treat missing mappings as errors, failing the record (`lookup_error` for a
+                static map, `lookupcache_evaluation_failed` for a lookup cache)
+              - omitted or null: the record doesn't fail either. On an import a static lookup writes
+                its default if it has one, and a static or cache lookup without one leaves the
+                mapped field out of the output, with no error
 
               **Recommendation**
 
@@ -14732,11 +14778,14 @@ components:
               - All possible source values are known and controlled
               - Missing mappings indicate serious data problems that should be addressed
 
-              The best practice is typically to set allowFailures to true with a meaningful
-              default value, so flows remain operational while alerting you to missing mappings.
+              A default raises no error: records that miss go out with the default value and
+              nothing reports them. Use true only when that fallback is acceptable at the
+              destination, and set false explicitly when a missing value must stop the record.
             examples:
               - true
               - false
+            x-celigo-ai-guidance:
+              - 'Never leave this field out to mean "fail on a miss": on an import, an omitted or null value lets a missing key through without an error (with the default, or without the mapped field when there is none). Only an explicit false fails the record.'
     Transform:
       type: object
       description: |
@@ -17374,16 +17423,22 @@ components:
           properties:
             postData:
               type: object
-              description: Additional data for the export preview
+              description: |-
+                Delta window for this preview. Without it, a document preview renders
+                `{{lastExportDateTime}}` and `{{currentExportDateTime}}` as empty strings (observed on
+                HTTP and RDBMS exports), so the preview doesn't reflect the export's delta window. On an
+                HTTP export these strings are substituted exactly as given; other adaptors weren't
+                checked. On an export without `delta.dateFormat`, a real run renders both as ISO 8601 UTC
+                with milliseconds, so pass them in that form to preview the request such a run would send.
               properties:
                 currentExportDateTime:
                   type: string
-                  description: Current export date time (timestamp)
-                  example: '1751909419'
+                  description: Value `{{currentExportDateTime}}` renders as in this preview (the window's end).
+                  example: '2026-01-16T00:00:00.000Z'
                 lastExportDateTime:
                   type: string
-                  description: Last export date time (timestamp)
-                  example: '1742641523'
+                  description: Value `{{lastExportDateTime}}` renders as in this preview (the window's start).
+                  example: '2026-01-15T00:00:00.000Z'
     PreviewResponse:
       type: object
       description: Response body for export data preview

package/dist/guardrail.yml

@@ -1985,7 +1985,7 @@ components:
           description: When true, the mapped value cannot be overwritten by later mapping steps.
         lookupName:
           type: string
-          description: Name of an entry in the import's `lookups` array used to translate the value.
+          description: Name of an entry in the import's `lookups` array (`http.lookups` on an HTTP import) used to translate the value.
           x-celigo-ai-guidance:
             - |-
               Name of a lookup defined on ``resource.lookups`` whose result

package/dist/import.yml

@@ -2717,7 +2717,9 @@ components:
 
               - **Field mappings** — a mapping entry sets
                 ``lookupName: "<name>"`` to resolve a field's value through
-                the lookup.
+                the lookup.  A ``lookupName`` that matches no entry in this
+                array fails every record with ``Unable to find lookup in
+                mapping configs - <name>``.
               - **Handlebars expressions** — anywhere handlebars is
                 evaluated (relativeURI, headers, body), ``{{lookup "name"
                 value}}`` calls the lookup with ``value`` as input.
@@ -2731,9 +2733,13 @@ components:
               ## Mirror invariant
 
               The Celigo platform persists lookups in TWO locations on an HTTP
-              import: top-level ``lookups`` and ``http.lookups``.  Both arrays
-              MUST hold byte-for-byte identical content, so write both on
-              every save.
+              import: top-level ``lookups`` and ``http.lookups``, and
+              ``http.lookups`` is the copy that counts.  A save keeps
+              ``http.lookups`` and mirrors it to the top level, overwriting a
+              top-level copy that differs; a ``lookups`` array sent only at the
+              top level is dropped with no error, on create and on PUT, and both
+              arrays read back null.  Write ``http.lookups`` on every save;
+              sending the same array at the top level too is harmless.
             - |-
               ## Static vs dynamic vs cached
 
@@ -2783,12 +2789,13 @@ components:
                   - handlebars
                 description: |
                   Request body template for POST / PUT / PATCH lookup methods, typically
-                  a JSON string with Handlebars placeholders (``{"email":"{{{email}}}"}``);
+                  a JSON string with Handlebars placeholders (``{"email":"{{email}}"}``);
                   ignored for GET / DELETE. The record's fields sit at the top level:
                   ``{{email}}`` renders the record's value, while ``{{record.email}}``
                   renders empty.
                 x-celigo-ai-guidance:
                   - 'Put the lookup''s request template here, not in ``postBody``: a ``postBody`` saves without an error but is not kept under ``http.lookups``, so the lookup goes out with no body and the run reports no error.'
+                  - 'Write string values with double braces inside the quotes (``"{{email}}"``): they are JSON-escaped at runtime. With triple braces a value holding a double quote breaks the request body, and the lookup quietly finds nothing, so an existence check writes the record as new.'
               headers:
                 type: array
                 items:
@@ -2844,10 +2851,17 @@ components:
                   - boolean
                   - 'null'
                 description: |
-                  When true, a lookup miss (no matching response and no
-                  ``default``) resolves to ``null`` and the import continues.
-                  When false (default), a miss halts the record. May be
-                  stored as null (treated as unset).
+                  When true, a lookup miss uses ``default`` (or leaves the mapped
+                  field out when there is none) and the record continues. When
+                  false, a miss fails the record: ``lookup_error`` ("Could not find
+                  value for static lookup: …") for a static ``map``,
+                  ``lookupcache_evaluation_failed`` for a cache. Omitted or null,
+                  a miss doesn't fail the record either: a static lookup writes
+                  its ``default`` if it has one, and a lookup without one (static,
+                  cache, or a live request that matches nothing or fails) leaves
+                  the mapped field out.
+                x-celigo-ai-guidance:
+                  - Set false explicitly when a miss must stop the record. Leaving the field out lets the record through with the default or without the looked-up value, so a destination that needs the real value gets a request without it and nothing errors.
               useDefaultOnMultipleMatches:
                 type: boolean
                 description: |
@@ -5077,8 +5091,8 @@ components:
               - Original value indicators: "{Original Value}", "No mapping found"
               - Neutral values: "Other", "N/A", "Miscellaneous"
 
-              If allowFailures is false and no default is specified, the flow will fail
-              when encountering unmapped values.
+              If allowFailures is false, a record whose value is unmapped fails and the default
+              is ignored.
             examples:
               - Unknown
               - Other
@@ -5099,7 +5113,11 @@ components:
               This field determines how the system handles source values that don't exist in the map:
 
               - true: Use the default value for missing mappings and continue processing
-              - false: Treat missing mappings as errors, failing the record
+              - false: Treat missing mappings as errors, failing the record (`lookup_error` for a
+                static map, `lookupcache_evaluation_failed` for a lookup cache)
+              - omitted or null: the record doesn't fail either. On an import a static lookup writes
+                its default if it has one, and a static or cache lookup without one leaves the
+                mapped field out of the output, with no error
 
               **Recommendation**
 
@@ -5113,11 +5131,14 @@ components:
               - All possible source values are known and controlled
               - Missing mappings indicate serious data problems that should be addressed
 
-              The best practice is typically to set allowFailures to true with a meaningful
-              default value, so flows remain operational while alerting you to missing mappings.
+              A default raises no error: records that miss go out with the default value and
+              nothing reports them. Use true only when that fallback is acceptable at the
+              destination, and set false explicitly when a missing value must stop the record.
             examples:
               - true
               - false
+            x-celigo-ai-guidance:
+              - 'Never leave this field out to mean "fail on a miss": on an import, an omitted or null value lets a missing key through without an error (with the default, or without the mapped field when there is none). Only an explicit false fails the record.'
     Rdbms:
       type: object
       description: |-
@@ -12661,6 +12682,12 @@ components:
             - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
               '$[*].Tax' (every row of a grouped record)
             - Wildcards like [*] extract multiple values/objects
+            - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+              `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+              path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+              need no brackets (`$.Ship To Name`, `$.Tracking #`)
+            - Filter expressions such as `$.items[?(@.active)]` fail the record with
+              "Eval [?(expr)] prevented in JSONPath expression."
 
             ```json
             "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -12849,6 +12876,12 @@ components:
             **Usage**
 
             The lookupName refers to a named lookup defined in the lookups array of the same resource.
+            On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+            is dropped on save. On an import, a name that matches no lookup fails every record
+            with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+            doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+            the field left out, lets the record succeed with the lookup's `default`, or without
+            the mapped field when there is none.
 
             ```json
             {
@@ -13186,6 +13219,11 @@ components:
                   The system creates special composite objects during processing to maintain
                   hierarchical relationships, allowing easy access to both the current array item
                   and its parent contexts.
+
+                  An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                  element per item, with no error. Child extracts drop the `[*]` but keep the
+                  array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                  element-relative `$.sku` reads the record root instead of the element.
                 examples:
                   - $.items[*]
                   - $.order.lineItems[*]
@@ -13397,14 +13435,17 @@ components:
           type: string
           description: |
             **Purpose**
-            Required on every mapping entry. Controls whether the mapping is applied.
+            Controls whether the mapping is applied. Send it on every mapping entry.
 
             **Guidance**
             Only `Active` rows run. `Draft` and `Inactive` rows keep their
             configuration, are saved with minimal validation, and are skipped at
             runtime and in preview; a non-Active parent skips its whole subtree
-            whatever its children say. The API rejects a mapping missing this field
-            (validation error: "Mapping object must have status field present.").
+            whatever its children say. Imports (on save and in the mapper processor)
+            and API response mappings reject a row missing this field (validation
+            error: "Mapping object must have status field present."); a Tool's
+            output mapping saves and runs one, which is why `required` doesn't
+            list it.
           x-celigo-ai-guidance:
             - |-
               Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -13727,6 +13768,12 @@ components:
               - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
                 '$[*].Tax' (every row of a grouped record)
               - Wildcards like [*] extract multiple values/objects
+              - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+                `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+                path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+                need no brackets (`$.Ship To Name`, `$.Tracking #`)
+              - Filter expressions such as `$.items[?(@.active)]` fail the record with
+                "Eval [?(expr)] prevented in JSONPath expression."
 
               ```json
               "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -13915,6 +13962,12 @@ components:
               **Usage**
 
               The lookupName refers to a named lookup defined in the lookups array of the same resource.
+              On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+              is dropped on save. On an import, a name that matches no lookup fails every record
+              with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+              doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+              the field left out, lets the record succeed with the lookup's `default`, or without
+              the mapped field when there is none.
 
               ```json
               {
@@ -14252,6 +14305,11 @@ components:
                     The system creates special composite objects during processing to maintain
                     hierarchical relationships, allowing easy access to both the current array item
                     and its parent contexts.
+
+                    An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                    element per item, with no error. Child extracts drop the `[*]` but keep the
+                    array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                    element-relative `$.sku` reads the record root instead of the element.
                   examples:
                     - $.items[*]
                     - $.order.lineItems[*]
@@ -14463,14 +14521,17 @@ components:
             type: string
             description: |
               **Purpose**
-              Required on every mapping entry. Controls whether the mapping is applied.
+              Controls whether the mapping is applied. Send it on every mapping entry.
 
               **Guidance**
               Only `Active` rows run. `Draft` and `Inactive` rows keep their
               configuration, are saved with minimal validation, and are skipped at
               runtime and in preview; a non-Active parent skips its whole subtree
-              whatever its children say. The API rejects a mapping missing this field
-              (validation error: "Mapping object must have status field present.").
+              whatever its children say. Imports (on save and in the mapper processor)
+              and API response mappings reject a row missing this field (validation
+              error: "Mapping object must have status field present."); a Tool's
+              output mapping saves and runs one, which is why `required` doesn't
+              list it.
             x-celigo-ai-guidance:
               - |-
                 Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -15140,7 +15201,7 @@ components:
           description: When true, the mapped value cannot be overwritten by later mapping steps.
         lookupName:
           type: string
-          description: Name of an entry in the import's `lookups` array used to translate the value.
+          description: Name of an entry in the import's `lookups` array (`http.lookups` on an HTTP import) used to translate the value.
           x-celigo-ai-guidance:
             - |-
               Name of a lookup defined on ``resource.lookups`` whose result
@@ -16592,8 +16653,9 @@ components:
 
               Lookups referenced by ``lookupName`` live on the top-level
               ``resource.lookups`` array (mirrored under the adaptor key for
-              adaptors that maintain their own copy — see the mirror invariant
-              on ``lookups``). Lookups are independent of this
+              adaptors that maintain their own copy; on an HTTP import that
+              copy, ``http.lookups``, is the one a save keeps — see the mirror
+              invariant on ``lookups``). Lookups are independent of this
               mapping: they are neither created nor cleared automatically when
               this mapping changes.
           properties:
@@ -16712,6 +16774,12 @@ components:
 
               Both arrays MUST hold byte-for-byte identical content: write
               both on every save and treat them as a single logical field.
+              On an HTTP import the adaptor copy decides: a save keeps
+              ``http.lookups`` and mirrors it here, overwriting a copy here
+              that differs, and an array sent only here is dropped on create
+              and on PUT with no error. A mapping row that names one of its
+              lookups then fails every record with ``Unable to find lookup in
+              mapping configs - <name>``.
             - |-
               ## Shape
 

package/dist/tool.yml

@@ -3638,6 +3638,12 @@ components:
             - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
               '$[*].Tax' (every row of a grouped record)
             - Wildcards like [*] extract multiple values/objects
+            - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+              `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+              path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+              need no brackets (`$.Ship To Name`, `$.Tracking #`)
+            - Filter expressions such as `$.items[?(@.active)]` fail the record with
+              "Eval [?(expr)] prevented in JSONPath expression."
 
             ```json
             "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -3826,6 +3832,12 @@ components:
             **Usage**
 
             The lookupName refers to a named lookup defined in the lookups array of the same resource.
+            On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+            is dropped on save. On an import, a name that matches no lookup fails every record
+            with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+            doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+            the field left out, lets the record succeed with the lookup's `default`, or without
+            the mapped field when there is none.
 
             ```json
             {
@@ -4163,6 +4175,11 @@ components:
                   The system creates special composite objects during processing to maintain
                   hierarchical relationships, allowing easy access to both the current array item
                   and its parent contexts.
+
+                  An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                  element per item, with no error. Child extracts drop the `[*]` but keep the
+                  array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                  element-relative `$.sku` reads the record root instead of the element.
                 examples:
                   - $.items[*]
                   - $.order.lineItems[*]
@@ -4374,14 +4391,17 @@ components:
           type: string
           description: |
             **Purpose**
-            Required on every mapping entry. Controls whether the mapping is applied.
+            Controls whether the mapping is applied. Send it on every mapping entry.
 
             **Guidance**
             Only `Active` rows run. `Draft` and `Inactive` rows keep their
             configuration, are saved with minimal validation, and are skipped at
             runtime and in preview; a non-Active parent skips its whole subtree
-            whatever its children say. The API rejects a mapping missing this field
-            (validation error: "Mapping object must have status field present.").
+            whatever its children say. Imports (on save and in the mapper processor)
+            and API response mappings reject a row missing this field (validation
+            error: "Mapping object must have status field present."); a Tool's
+            output mapping saves and runs one, which is why `required` doesn't
+            list it.
           x-celigo-ai-guidance:
             - |-
               Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -4704,6 +4724,12 @@ components:
               - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
                 '$[*].Tax' (every row of a grouped record)
               - Wildcards like [*] extract multiple values/objects
+              - A key that contains a dot needs bracket notation: `$['P.O. Number']` (or
+                `$["P.O. Number"]`, `$.[P.O. Number]`). `$.P.O. Number` is read as a nested
+                path: it maps nothing and the record still succeeds. Spaces, hyphens and `#`
+                need no brackets (`$.Ship To Name`, `$.Tracking #`)
+              - Filter expressions such as `$.items[?(@.active)]` fail the record with
+                "Eval [?(expr)] prevented in JSONPath expression."
 
               ```json
               "extract": "$.customer.addresses[*]"  // Extracts all addresses
@@ -4892,6 +4918,12 @@ components:
               **Usage**
 
               The lookupName refers to a named lookup defined in the lookups array of the same resource.
+              On an HTTP import that is `http.lookups`: a `lookups` array sent only at the top level
+              is dropped on save. On an import, a name that matches no lookup fails every record
+              with "Unable to find lookup in mapping configs - <name>", and a key the lookup
+              doesn't hold follows the lookup's `allowFailures`: false fails the record; true, or
+              the field left out, lets the record succeed with the lookup's `default`, or without
+              the mapped field when there is none.
 
               ```json
               {
@@ -5229,6 +5261,11 @@ components:
                     The system creates special composite objects during processing to maintain
                     hierarchical relationships, allowing easy access to both the current array item
                     and its parent contexts.
+
+                    An iterating entry keeps the `[*]`: `$.line_items` without it yields one empty
+                    element per item, with no error. Child extracts drop the `[*]` but keep the
+                    array's path (`$.line_items.sku`); `$.line_items[*].sku` maps nothing, and an
+                    element-relative `$.sku` reads the record root instead of the element.
                   examples:
                     - $.items[*]
                     - $.order.lineItems[*]
@@ -5440,14 +5477,17 @@ components:
             type: string
             description: |
               **Purpose**
-              Required on every mapping entry. Controls whether the mapping is applied.
+              Controls whether the mapping is applied. Send it on every mapping entry.
 
               **Guidance**
               Only `Active` rows run. `Draft` and `Inactive` rows keep their
               configuration, are saved with minimal validation, and are skipped at
               runtime and in preview; a non-Active parent skips its whole subtree
-              whatever its children say. The API rejects a mapping missing this field
-              (validation error: "Mapping object must have status field present.").
+              whatever its children say. Imports (on save and in the mapper processor)
+              and API response mappings reject a row missing this field (validation
+              error: "Mapping object must have status field present."); a Tool's
+              output mapping saves and runs one, which is why `required` doesn't
+              list it.
             x-celigo-ai-guidance:
               - |-
                 Emit `"Active"` for mappings that should run; `"Draft"` is also
@@ -5818,8 +5858,8 @@ components:
               - Original value indicators: "{Original Value}", "No mapping found"
               - Neutral values: "Other", "N/A", "Miscellaneous"
 
-              If allowFailures is false and no default is specified, the flow will fail
-              when encountering unmapped values.
+              If allowFailures is false, a record whose value is unmapped fails and the default
+              is ignored.
             examples:
               - Unknown
               - Other
@@ -5840,7 +5880,11 @@ components:
               This field determines how the system handles source values that don't exist in the map:
 
               - true: Use the default value for missing mappings and continue processing
-              - false: Treat missing mappings as errors, failing the record
+              - false: Treat missing mappings as errors, failing the record (`lookup_error` for a
+                static map, `lookupcache_evaluation_failed` for a lookup cache)
+              - omitted or null: the record doesn't fail either. On an import a static lookup writes
+                its default if it has one, and a static or cache lookup without one leaves the
+                mapped field out of the output, with no error
 
               **Recommendation**
 
@@ -5854,11 +5898,14 @@ components:
               - All possible source values are known and controlled
               - Missing mappings indicate serious data problems that should be addressed
 
-              The best practice is typically to set allowFailures to true with a meaningful
-              default value, so flows remain operational while alerting you to missing mappings.
+              A default raises no error: records that miss go out with the default value and
+              nothing reports them. Use true only when that fallback is acceptable at the
+              destination, and set false explicitly when a missing value must stop the record.
             examples:
               - true
               - false
+            x-celigo-ai-guidance:
+              - 'Never leave this field out to mean "fail on a miss": on an import, an omitted or null value lets a missing key through without an error (with the default, or without the mapped field when there is none). Only an explicit false fails the record.'
     Transform:
       type: object
       description: |
@@ -14411,7 +14458,9 @@ components:
 
               - **Field mappings** — a mapping entry sets
                 ``lookupName: "<name>"`` to resolve a field's value through
-                the lookup.
+                the lookup.  A ``lookupName`` that matches no entry in this
+                array fails every record with ``Unable to find lookup in
+                mapping configs - <name>``.
               - **Handlebars expressions** — anywhere handlebars is
                 evaluated (relativeURI, headers, body), ``{{lookup "name"
                 value}}`` calls the lookup with ``value`` as input.
@@ -14425,9 +14474,13 @@ components:
               ## Mirror invariant
 
               The Celigo platform persists lookups in TWO locations on an HTTP
-              import: top-level ``lookups`` and ``http.lookups``.  Both arrays
-              MUST hold byte-for-byte identical content, so write both on
-              every save.
+              import: top-level ``lookups`` and ``http.lookups``, and
+              ``http.lookups`` is the copy that counts.  A save keeps
+              ``http.lookups`` and mirrors it to the top level, overwriting a
+              top-level copy that differs; a ``lookups`` array sent only at the
+              top level is dropped with no error, on create and on PUT, and both
+              arrays read back null.  Write ``http.lookups`` on every save;
+              sending the same array at the top level too is harmless.
             - |-
               ## Static vs dynamic vs cached
 
@@ -14477,12 +14530,13 @@ components:
                   - handlebars
                 description: |
                   Request body template for POST / PUT / PATCH lookup methods, typically
-                  a JSON string with Handlebars placeholders (``{"email":"{{{email}}}"}``);
+                  a JSON string with Handlebars placeholders (``{"email":"{{email}}"}``);
                   ignored for GET / DELETE. The record's fields sit at the top level:
                   ``{{email}}`` renders the record's value, while ``{{record.email}}``
                   renders empty.
                 x-celigo-ai-guidance:
                   - 'Put the lookup''s request template here, not in ``postBody``: a ``postBody`` saves without an error but is not kept under ``http.lookups``, so the lookup goes out with no body and the run reports no error.'
+                  - 'Write string values with double braces inside the quotes (``"{{email}}"``): they are JSON-escaped at runtime. With triple braces a value holding a double quote breaks the request body, and the lookup quietly finds nothing, so an existence check writes the record as new.'
               headers:
                 type: array
                 items:
@@ -14538,10 +14592,17 @@ components:
                   - boolean
                   - 'null'
                 description: |
-                  When true, a lookup miss (no matching response and no
-                  ``default``) resolves to ``null`` and the import continues.
-                  When false (default), a miss halts the record. May be
-                  stored as null (treated as unset).
+                  When true, a lookup miss uses ``default`` (or leaves the mapped
+                  field out when there is none) and the record continues. When
+                  false, a miss fails the record: ``lookup_error`` ("Could not find
+                  value for static lookup: …") for a static ``map``,
+                  ``lookupcache_evaluation_failed`` for a cache. Omitted or null,
+                  a miss doesn't fail the record either: a static lookup writes
+                  its ``default`` if it has one, and a lookup without one (static,
+                  cache, or a live request that matches nothing or fails) leaves
+                  the mapped field out.
+                x-celigo-ai-guidance:
+                  - Set false explicitly when a miss must stop the record. Leaving the field out lets the record through with the default or without the looked-up value, so a destination that needs the real value gets a request without it and nothing errors.
               useDefaultOnMultipleMatches:
                 type: boolean
                 description: |
@@ -24058,7 +24119,7 @@ components:
           description: When true, the mapped value cannot be overwritten by later mapping steps.
         lookupName:
           type: string
-          description: Name of an entry in the import's `lookups` array used to translate the value.
+          description: Name of an entry in the import's `lookups` array (`http.lookups` on an HTTP import) used to translate the value.
           x-celigo-ai-guidance:
             - |-
               Name of a lookup defined on ``resource.lookups`` whose result
@@ -25510,8 +25571,9 @@ components:
 
               Lookups referenced by ``lookupName`` live on the top-level
               ``resource.lookups`` array (mirrored under the adaptor key for
-              adaptors that maintain their own copy — see the mirror invariant
-              on ``lookups``). Lookups are independent of this
+              adaptors that maintain their own copy; on an HTTP import that
+              copy, ``http.lookups``, is the one a save keeps — see the mirror
+              invariant on ``lookups``). Lookups are independent of this
               mapping: they are neither created nor cleared automatically when
               this mapping changes.
           properties:
@@ -25630,6 +25692,12 @@ components:
 
               Both arrays MUST hold byte-for-byte identical content: write
               both on every save and treat them as a single logical field.
+              On an HTTP import the adaptor copy decides: a save keeps
+              ``http.lookups`` and mirrors it here, overwriting a copy here
+              that differs, and an array sent only here is dropped on create
+              and on PUT with no error. A mapping row that names one of its
+              lookups then fails every record with ``Unable to find lookup in
+              mapping configs - <name>``.
             - |-
               ## Shape
 
@@ -31090,6 +31158,8 @@ components:
             Controls how the export requests subsequent pages when the API returns multi-page responses. The `method` field determines which companion fields are required and how each next page is requested. For the page, skip, and token methods, reference the matching pagination variable (`{{export.http.paging.page}}`, `{{export.http.paging.skip}}`, or `{{export.http.paging.token}}`) in the relative URI or request body — misconfigured pagination is a common cause of incomplete data retrieval.
 
             When this export is the first lookup of a builder-mode API with `pagination.enabled` set, it is that API's volume driver: saving the export (even unchanged) invalidates the API's issued cursors, so a caller mid-walk gets an empty final page, and removing `paging` is accepted on save but makes every call to the API fail with `400 api_pagination_source_not_paged` until paging is restored or the API's flag is turned off.
+
+            When a next page's response is identical to the previous one, paging stops: the export records an open error with code `page_response_error` ("Identical response received from next page request. No more page requests will be made.") and the run completes with the pages already read, so later pages are never exported. A request that doesn't change between pages produces this, as observed with `method: page` and the pagination variable missing from the relative URI and body; reference the variable so each request asks for the next page.
           x-celigo-ai-guidance:
             - Configuration object for navigating through multi-page API responses.
             - |-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celigo/api-specs",
-  "version": "0.2.151",
+  "version": "0.2.153",
   "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": "48f349ad",
+		"iasCommit": "edaea717",
 		"generatedAt": "2026-10-21"
 	},
 	"roots": {