@celigo/api-specs 0.2.214 → 0.2.216

package/dist/export.yml

@@ -15412,12 +15412,16 @@ components:
                     - |-
                       On a grouped record (the export groups rows, so the record is an
                       array) only `create` can author output — build it from the rows with
-                      `$[0].field`, `$[*].field`, or a `buildArrayHelper` over `$[*]`.
+                      `$[0].field`, `$[*].field`, or a `buildArrayHelper` over `$[*]`
+                      (`$.rows[0].field` and `$.rows[*]` with `inputContext: envelope`).
                       `modify` has no object to overlay onto an array: the record passes
-                      through untouched and the processor reports success. Either mode
-                      reshapes the inside of one record; neither changes how many records
-                      the page carries (that is the export's `preSavePage` hook) or whether
-                      the export groups at all (that is its grouping setting).
+                      through untouched and the processor reports success. Paths written
+                      for one object record (`$.field`, an entry `$.lines[*]`) resolve
+                      nothing there, so `create` returns `{}` for each record, also with
+                      no error (live, 2026-10-30). Either mode reshapes the inside of one
+                      record; neither changes how many records the page carries (that is
+                      the export's `preSavePage` hook) or whether the export groups at all
+                      (that is its grouping setting).
                   examples:
                     - create
                     - modify
@@ -15482,8 +15486,8 @@ components:
                     - record
                     - envelope
                   x-enumDescriptions:
-                    record: The transform processor evaluates `mappings[].extract` JSONPath against the flat record itself (`$.field`, no `record.` segment) — the default when absent.
-                    envelope: The transform processor evaluates JSONPath against the wrapped runtime envelope `{record, job, testMode, settings, headers, queryParams}` (file-provider steps also carry `fileMeta`) — record fields need the `record.` segment (`$.record.field`), while `headers` and `queryParams` sit beside `record` (`$.headers['X-Id']`, `$.queryParams.src`).
+                    record: The transform processor evaluates `mappings[].extract` JSONPath against the flat record itself (`$.field`, no `record.` segment; a grouped record is the array of rows, `$[0].field`) — the default when absent.
+                    envelope: The transform processor evaluates JSONPath against the wrapped runtime envelope `{record, job, testMode, settings, headers, queryParams}` (file-provider steps also carry `fileMeta`) — record fields need the `record.` segment (`$.record.field`), and a grouped record sits under `rows` instead (`$.rows[0].field`), while `headers` and `queryParams` sit beside `record` (`$.headers['X-Id']`, `$.queryParams.src`).
                   description: |
                     Controls the JSON shape the transformTwoDotZero processor
                     evaluates `mappings[].extract` JSONPath values against at
@@ -15499,24 +15503,38 @@ components:
                         processor sees the FLAT record as its evaluation root.
                         `mappings[].extract` JSONPath MUST anchor directly at
                         `$` with NO `record.` segment — e.g. `"$.orderId"`,
-                        `"$.customer.email"`; PLACEHOLDER extracts use
+                        `"$.customer.email"` on an object record, `"$[0].orderId"`
+                        on a grouped one; PLACEHOLDER extracts use
                         `"$.PLACEHOLDER_<field>"`.
                         This is the dominant Celigo idiom and the right choice for new transforms.
                       - `envelope`: the processor sees a wrapped object
                         `{record: {...}, job, testMode, settings, headers,
                         queryParams}` (plus `fileMeta` on file-provider steps).
                         `mappings[].extract` JSONPath MUST include the
-                        `record.` segment for record fields — e.g.
-                        `"$.record.orderId"` — and reads `headers` and
+                        `record.` segment for an object record's fields — e.g.
+                        `"$.record.orderId"`; a grouped record sits under `rows`
+                        instead (`"$.rows[0].orderId"`) — and reads `headers` and
                         `queryParams` beside it (`$.headers['X-Id']`);
                         PLACEHOLDER extracts use `"$.record.PLACEHOLDER_<field>"`.
                         Pick this only when the transform was authored against
                         the envelope shape on purpose.
                     - |-
-                      Handlebars expressions inside `extract`
-                      (`{{record.field}}`, `{{dateFormat ... record.field}}`)
-                      ALWAYS reference the `record` root regardless of
+                      Handlebars expressions inside `extract` reference the
+                      `record` root on an object record (`{{record.field}}`,
+                      `{{dateFormat ... record.field}}`) and `rows` on a
+                      grouped one (`{{rows.0.field}}`), regardless of
                       `inputContext` — only JSONPath anchoring flips.
+                    - |-
+                      ## Grouped records
+
+                      When the export groups rows, each record is an array of
+                      rows. In `record` mode JSONPath roots at that array
+                      (`$[0].field`, `$[*]`); `envelope` binds it as `rows`,
+                      not `record` — `$.rows[0].field`, and an entry
+                      `$.rows[*]` whose children read `$.rows.field` — while
+                      `$.record[0].field` and `$.record[*]` resolve nothing,
+                      with no error (live, 2026-10-30). Handlebars extracts
+                      read it as `rows` in both modes (`{{rows.0.field}}`).
                     - |-
                       In `envelope` mode the output is still a bare record: a
                       `modify` transform returns the record with its mapped
@@ -15537,7 +15555,8 @@ components:
                         ``mappings[].extract`` JSONPath values MUST anchor
                         directly at ``$`` with NO ``record.`` segment — for
                         example ``"$.orderId"`` or
-                        ``"$.customer.email"``.  PLACEHOLDER extracts use
+                        ``"$.customer.email"`` on an object record, and
+                        ``"$[0].orderId"`` on a grouped one.  PLACEHOLDER extracts use
                         ``"$.PLACEHOLDER_<field>"``.  This is the dominant
                         Celigo idiom and the right choice for new transforms.
 
@@ -15549,9 +15568,10 @@ components:
                         ``record``) — the
                         same runtime-context envelope Handlebars / SQL /
                         GraphQL templates render against.  ``mappings[].extract``
-                        JSONPath values for record fields MUST include the
+                        JSONPath values for an object record's fields MUST include the
                         ``record.`` segment — for example ``"$.record.orderId"``
-                        or ``"$.record.customer.email"`` — while ``headers`` and
+                        or ``"$.record.customer.email"``; a grouped record's rows
+                        sit under ``rows`` instead (``"$.rows[0].orderId"``) — while ``headers`` and
                         ``queryParams`` are read beside it
                         (``"$.headers['X-Id']"``).  PLACEHOLDER extracts
                         use ``"$.record.PLACEHOLDER_<field>"``.  Pick this
@@ -15564,8 +15584,9 @@ components:
 
                       Handlebars expressions inside ``extract``
                       (``{{record.field}}``,
-                      ``{{dateFormat ... record.field}}``, etc.) ALWAYS
-                      reference the runtime context's ``record`` root
+                      ``{{dateFormat ... record.field}}``, etc.) reference the
+                      runtime context's ``record`` root on an object record,
+                      and ``rows`` (``{{rows.0.field}}``) on a grouped one,
                       regardless of ``inputContext`` — the Handlebars runtime
                       always sees the wrapped envelope.  Only JSONPath
                       behavior flips with this field.
@@ -16426,8 +16447,8 @@ components:
         **Structure**
 
         The mock output must follow the integrator.io canonical format, which consists of a
-        `page_of_records` array containing record objects. Each record object has a `record`
-        property that contains the actual data fields.
+        `page_of_records` array of items. On an export that does not group rows, each item has a
+        `record` property that contains the actual data fields:
 
         ```json
         {
@@ -16444,6 +16465,19 @@ components:
         }
         ```
 
+        An export that groups rows (`groupByFields`) produces records that are arrays of rows, and
+        each item then carries `rows` instead of `record`, holding the rows of one grouped record. A
+        flow test run saves a grouped export's records in this form:
+
+        ```json
+        {
+          "page_of_records": [
+            { "rows": [ { "field1": "value1" }, { "field1": "value2" } ] },
+            ...
+          ]
+        }
+        ```
+
         **Usage**
 
         In a flow test run, and for an upstream lookup during a page-processor preview
@@ -16476,7 +16510,8 @@ components:
 
         - Maximum of 10 records
         - Maximum size of 1 MB
-        - Must follow the canonical format shown above
+        - Must follow one of the canonical formats shown above: every item `{"record": {...}}`, or
+          on a grouped export every item `{"rows": [...]}`
 
         Mock output can be populated automatically from preview data (which is the parsed response,
         before `transform` / `filter`) or entered manually.
@@ -16518,6 +16553,22 @@ components:
                   categories:
                     - Electronics
                     - Accessories
+              rows:
+                type: array
+                description: |
+                  The rows of one grouped record, present instead of `record` when the export
+                  groups rows (`groupByFields`). Every item of a grouped export's mock carries
+                  `rows`.
+                items:
+                  type: object
+                  additionalProperties: true
+                example:
+                  - orderId: SO-1001
+                    sku: SKU-100
+                    quantity: 2
+                  - orderId: SO-1001
+                    sku: SKU-200
+                    quantity: 1
       example:
         page_of_records:
           - record:

package/dist/flow.yml

@@ -2153,12 +2153,14 @@ paths:
 
         The `data` field is the record as the failing stage held it: for an import-stage error
         (`page_processor_import`) on an HTTP import, the record before the import's mappings, not the
-        request the import sent; for a postResponseMap hook's error (`post_response_mapping`), the record
+        request the import sent; for a lookup's error (`page_processor_export`), the record as it reached
+        the lookup; for a postResponseMap hook's error (`post_response_mapping`), the record
         after the step's response mapping. Use `PUT .../{retryDataKey}/data` to mutate
         the snapshot before retrying. Only errors with a `retryDataKey` expose this endpoint;
         connection-class errors are rejected with `no_retrydata_found`. The `stage` field indicates
         where the retry will resume: `page_processor_import` re-runs the import (most common, and where a
-        postSubmit hook's errors are stored, so their retry writes the records again),
+        postSubmit hook's errors are stored — a retry writes again a record the destination accepted,
+        and resends one whose refusal the hook reworded), `page_processor_export` re-runs the lookup,
         `post_response_mapping` (a postResponseMap hook's error) resumes after the import from the stored
         reply in `adaptorResponse`, sending nothing to the destination again and carrying the record on
         to the flow's next steps, and `page_generator` means the error was upstream of the processor.
@@ -4342,6 +4344,10 @@ paths:
 
         An empty object `{}` means no other resources depend on the target — this is also returned for a
         well-formatted but nonexistent id.
+
+        A `flows` entry whose `paths` holds `_runNextFlowIds` is an upstream flow: its own
+        `_runNextFlowIds` lists this flow, so this flow starts when a run of that one completes. The
+        flows this flow starts are in its own `_runNextFlowIds`, not in this response.
       parameters:
         - name: _id
           in: path
@@ -4364,7 +4370,7 @@ paths:
                   summary: No dependents (also returned for a nonexistent id)
                   value: {}
                 populated:
-                  summary: Another flow is configured to run after this one
+                  summary: Another flow starts this one when its run completes
                   value:
                     flows:
                       - id: 69f4b2cb95ec28be9ca1a88d
@@ -5847,9 +5853,11 @@ components:
             - string
             - 'null'
           description: |-
-            IANA timezone for the schedule (e.g. `America/New_York`). Defaults to UTC. The flow's
-            `schedule` and each page generator's own `schedule` are read in this timezone; a page
-            generator has no timezone of its own.
+            IANA timezone for the schedule (e.g. `America/New_York`). The flow's `schedule` and each
+            page generator's own `schedule` are read in this timezone; a page generator has no
+            timezone of its own. A flow saved without one stores none, and its schedule then runs in
+            UTC when the account owner's profile has no time zone; per the Help Center's time zone
+            precedence, it runs in the owner's profile time zone when the profile sets one.
           examples:
             - America/New_York
             - Europe/London
@@ -6935,8 +6943,10 @@ components:
             `application` covers the step's whole call to the external system, not only its answer:
             besides errors the destination returned, it marks a request that never got an answer,
             such as a URL template that failed to render (`handlebars_template_parse_error`) or a
-            refused connection, so read `code` and `message` with it. `GET /v1/errors/filterMetadata`
-            lists the source values the errors filter accepts.
+            refused connection, so read `code` and `message` with it. `post_submit_hook` marks an error
+            a postSubmit hook added or reworded — a destination refusal included — while one the hook
+            passes along unchanged keeps `application`, so it does not mean the destination accepted the
+            record. `GET /v1/errors/filterMetadata` lists the source values the errors filter accepts.
           examples:
             - application
         code:
@@ -7831,7 +7841,8 @@ components:
             (an import's errors, a postSubmit hook's included) it is the incoming record, before the
             import's mappings — not the request body the import sent or the response it got back — and a
             retry maps it again with the import's current mappings, so a mapping fix reaches the retried
-            record. At `post_response_mapping` (a postResponseMap hook's error) it is the record after the
+            record. At `page_processor_export` (a lookup's errors) it is the record as it reached the
+            lookup. At `post_response_mapping` (a postResponseMap hook's error) it is the record after the
             step's response mapping, with the mapped fields: a retry neither maps nor sends it again, and
             the destination's reply is in `adaptorResponse`. Shape varies by adaptor.
           additionalProperties: true
@@ -7840,14 +7851,25 @@ components:
           description: |-
             Pipeline stage where the record was when the error occurred, which is where a retry resumes.
             `page_processor_import` is the record as it entered the import, so a retry sends it to the
-            destination again; a postSubmit hook's errors are stored here, so retrying them writes records
-            the destination already accepted a second time (live, 2026-10-22). `post_response_mapping` is a
-            postResponseMap hook's error, raised after the destination answered: a retry runs the hook from
-            the stored reply and carries the record on to the flow's next steps, sending nothing to that
-            destination again (live, 2026-10-23 and 2026-10-25: the import's request count didn't change,
-            and the next import received the retried records).
+            destination again. A postSubmit hook's errors are stored here whether the destination accepted
+            the record or refused it and the hook reworded the refusal (live, 2026-10-30), so neither the
+            stage nor the error's `post_submit_hook` source says whether the record was written: retrying
+            an error the hook raised after the destination accepted the record writes it a second time
+            (live, 2026-10-22), while a reworded refusal is a record the destination did not take.
+            `page_processor_export` is a lookup's error: a retry runs the lookup again as it is configured
+            now (live, 2026-10-30: after the lookup's template was fixed, the retried records succeeded).
+            `post_response_mapping` is a postResponseMap hook's error, raised after the destination
+            answered: a retry runs the hook from the stored reply and carries the record on to the flow's
+            next steps, sending nothing to that destination again (live, 2026-10-23 and 2026-10-25: the
+            import's request count didn't change, and the next import received the retried records).
+          x-celigo-ai-guidance:
+            - |-
+              Before retrying `post_submit_hook` errors, find out whether the destination took each
+              record — the hook's message, or a lookup of the record in the destination — and retry the
+              refusals. A hook error on a record the destination accepted is written again by the retry.
           examples:
             - page_processor_import
+            - page_processor_export
             - post_response_mapping
             - importMappingExtract
         pgExportId:

package/dist/guardrail.yml

@@ -602,8 +602,10 @@ components:
           - **openai**: OpenAI models (GPT-4.1, GPT-5, etc.). Configure via the `openai` object.
           - **gemini**: Google Gemini models via the LiteLLM proxy. Configure via `litellm` with overrides in `litellm._overrides.gemini`.
           - **anthropic**: Anthropic Claude models via the LiteLLM proxy. Configure via `litellm` with overrides in `litellm._overrides.anthropic`.
-        - **Catalog providers** — `mistral`, `xai`, `huggingface`, `deepseek`, `cohere`, `groq`. Added
-          as catalog data rather than platform code, they share one generic flat format:
+        - **Catalog providers** — every other value of `provider` (Mistral, xAI, Hugging Face,
+          DeepSeek, Cohere, Groq, Together AI, Azure OpenAI, Fireworks AI, AWS Bedrock, NVIDIA NIM,
+          Ollama Cloud and Google Vertex AI today; the catalog grows without a platform release).
+          Added as catalog data rather than platform code, they share one generic flat format:
           `model`, `modelOptions`, `instructions`, `output`, and the `prompts` / `resources`
           arrays directly on this object.
 
@@ -655,26 +657,43 @@ components:
             - deepseek
             - cohere
             - groq
+            - together_ai
+            - azure_ai
+            - fireworks_ai
+            - bedrock
+            - nvidia_nim
+            - ollama_chat
+            - vertex_ai
           x-enumDescriptions:
-            openai: Use OpenAI models via the OpenAI Responses API (built-in; `openai` block).
-            gemini: Use Google Gemini models via the LiteLLM proxy (built-in; `litellm` block).
-            anthropic: Use Anthropic Claude models via the LiteLLM proxy (built-in; `litellm` block).
-            mistral: Use Mistral models (catalog provider; generic flat format, BYOK).
-            xai: Use xAI Grok models (catalog provider; generic flat format, BYOK).
-            huggingface: Use Hugging Face inference endpoint models (catalog provider; generic flat format, BYOK).
-            deepseek: Use DeepSeek models (catalog provider; generic flat format, BYOK).
-            cohere: Use Cohere models (catalog provider; generic flat format, BYOK).
-            groq: Use Groq-hosted models (catalog provider; generic flat format, BYOK).
-          description: AI provider to use.
+            openai: Use OpenAI models via the OpenAI Responses API (built-in; `openai` block; Celigo AI or BYOK)
+            gemini: Use Google Gemini models via the LiteLLM proxy (built-in; `litellm` block; Celigo AI or BYOK)
+            anthropic: Use Anthropic Claude models via the LiteLLM proxy (built-in; `litellm` block; Celigo AI or BYOK)
+            mistral: Use Mistral models (catalog provider; generic flat format, BYOK)
+            xai: Use xAI Grok models (catalog provider; generic flat format, BYOK)
+            huggingface: Use Hugging Face inference endpoint models (catalog provider; generic flat format, BYOK)
+            deepseek: Use DeepSeek models (catalog provider; generic flat format, BYOK)
+            cohere: Use Cohere models (catalog provider; generic flat format, BYOK)
+            groq: Use Groq-hosted models (catalog provider; generic flat format, BYOK)
+            together_ai: Use models served by Together AI (catalog provider; generic flat format, BYOK)
+            azure_ai: Use deployments on an Azure AI Foundry / Azure OpenAI resource — `model` is the deployment name (catalog provider; generic flat format, BYOK)
+            fireworks_ai: Use models served by Fireworks AI (catalog provider; generic flat format, BYOK)
+            bedrock: Use AWS Bedrock models through cross-region inference profile ids such as `global.anthropic.claude-sonnet-4-6` (catalog provider; generic flat format, BYOK)
+            nvidia_nim: Use models served by NVIDIA NIM (catalog provider; generic flat format, BYOK)
+            ollama_chat: Use models served by Ollama Cloud (catalog provider; generic flat format, BYOK)
+            vertex_ai: Use Gemini models on Google Vertex AI with the customer's own GCP project (catalog provider; generic flat format, BYOK)
+          description: |-
+            AI provider to use. Built-in providers run on Celigo AI credentials or on a
+            BYOK connection; every other provider is a catalog row that runs only on a BYOK
+            connection. The catalog is data — a provider can be added without a platform
+            release, and `GET /api/aiproviders` lists the rows currently offered.
           x-celigo-ai-guidance:
             - |-
               The provider decides the configuration format, and the server rejects a
               mismatch with 422 `invalid_provider_config_format`: `openai` needs the
               `openai` block, `gemini` and `anthropic` need the `litellm` block (Gemini- or
-              Claude-specific settings under `litellm._overrides`), and the catalog
-              providers (`mistral`, `xai`, `huggingface`, `deepseek`, `cohere`, `groq`) need the
-              generic flat format — `model` and `modelOptions` directly on this object,
-              never an `openai` or `litellm` block.
+              Claude-specific settings under `litellm._overrides`), and every other
+              provider (the catalog providers) needs the generic flat format — `model` and
+              `modelOptions` directly on this object, never an `openai` or `litellm` block.
             - |-
               Catalog providers are BYOK-only, and the save enforces it through the model
               catalog: without a `_connectionId` the guardrail fails to save with 422
@@ -683,6 +702,18 @@ components:
               configuration.") — the model is a catalog row that is not offered on
               platform-managed credentials. Attach an HTTP connection to the vendor's API
               (token auth) before saving a catalog-provider guardrail.
+            - |-
+              Without a connection, a provider the catalog does not list is refused at the
+              model check — 422 `ai_model_not_in_catalog` on `guardrail.aiAgent.model` — so the
+              message names the model, not the provider. Check the provider against the
+              catalog before blaming the model.
+            - |-
+              For `azure_ai` and `bedrock` the vendor-specific settings ride the BYOK
+              connection, not this object: an optional connection `baseURI` (the vendor
+              endpoint the connector asks for), and connection settings forwarded to the
+              vendor — Azure's `apiVersion`, Bedrock's `awsRegionName`. `bedrock`
+              authenticates with a Bedrock API key (no IAM role); for `azure_ai`, `model` is
+              the deployment name.
         model:
           type: string
           description: |-
@@ -1566,6 +1597,13 @@ components:
                   - deepseek
                   - cohere
                   - groq
+                  - together_ai
+                  - azure_ai
+                  - fireworks_ai
+                  - bedrock
+                  - nvidia_nim
+                  - ollama_chat
+                  - vertex_ai
             required:
               - provider
           then:
@@ -2389,7 +2427,7 @@ components:
             Connection for BYOK (bring your own key) — only meaningful for `ai_agent` type
             guardrails. Optional for the built-in providers (`openai`, `gemini`, `anthropic`),
             which run on platform-managed credentials when it is omitted; catalog providers
-            (`mistral`, `xai`, `huggingface`, `deepseek`, `cohere`, `groq`) have no platform-managed
+            (every other value of `provider`) have no platform-managed
             credentials and need it to run.
           examples:
             - 68ae48d6b5f755d2dd38c294