@celigo/api-specs 0.2.215 → 0.2.217

package/dist/tool.yml

@@ -21592,8 +21592,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 `tools` / `prompts` /
           `resources` arrays directly on this object.
 
@@ -21639,26 +21641,45 @@ 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.
+              Switching across that boundary replaces the whole configuration in the target
+              format; nothing is translated field by field.
             - |-
               Catalog providers are BYOK-only, and the save enforces it through the model
               catalog: without a `_connectionId` the agent fails to save with 422
@@ -21667,6 +21688,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 agent.
+            - |-
+              Without a connection, a provider the catalog does not list is refused at the
+              model check — 422 `ai_model_not_in_catalog` on `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: |-
@@ -22139,13 +22172,27 @@ components:
                       web_search: Search the web for real-time information.
                       mcp: Connect to an MCP server for additional external tools.
                       image_generation: Generate images using an AI image model.
-                      code_execution: 'Enable OpenAI''s built-in code-execution tool; carries no configuration block, send `{type: code_execution}` only'
+                      code_execution: 'Let the model write and run code in OpenAI''s sandbox on a BYOK agent; carries no configuration block, send `{type: code_execution}` only'
                       tool: Reference a reusable Celigo Tool resource.
                     description: |-
                       Type of tool. Every type except `code_execution` is configured through the
                       sibling object of the same name; OpenAI spells this one `code_execution`, while
                       the Gemini and Anthropic overrides spell theirs `codeExecution` — the other spelling
-                      fails with 422 `enum`.
+                      fails with 422 `enum`. Code execution runs only on a BYOK agent and only on
+                      models that support it: the code runs in OpenAI's sandbox with no outbound
+                      network access, the session lasts one hour, and each execution is billed as an
+                      AI Action to the connection's OpenAI account rather than as Celigo AI credits.
+                    x-celigo-ai-guidance:
+                      - |-
+                        Add `code_execution` only when the agent has a `_connectionId`. The save does
+                        not check the credential type, but every run and preview of an agent on
+                        Celigo-managed credentials is refused with `Code Execution requires a BYOK
+                        connection.` — switch the agent to a BYOK connection or leave the tool out.
+                      - |-
+                        Send the tool as `{type: code_execution}` with no other key — a sandbox or
+                        options object on it is rejected. Check that the chosen model supports code
+                        execution before adding it; the platform does not verify that at save and
+                        the UI hides the tool for models that lack it.
                   webSearch:
                     type: object
                     description: Web search configuration (empty object to enable)
@@ -22499,12 +22546,28 @@ components:
                               googleSearch: Use Google Search for real-time information grounding.
                               urlContext: Retrieve and use content from specified URLs.
                               fileSearch: Search through previously uploaded files.
-                              codeExecution: 'Enable Gemini''s built-in code-execution tool; carries no configuration block, send `{type: codeExecution}` only'
+                              codeExecution: 'Let the model write and run code in Gemini''s sandbox on a BYOK agent; carries no configuration block, send `{type: codeExecution}` only'
                               mcp: Connect to an MCP server for additional external tools.
                               tool: Reference a reusable Celigo Tool resource.
                             description: |-
                               Type of Gemini tool. `codeExecution` is the Gemini spelling — `code_execution`
-                              fails with 422 `enum`.
+                              fails with 422 `enum`. Code execution runs only on a BYOK agent and only on
+                              models that support it (not on `gemini-2.5-flash-image`): the code runs in
+                              Gemini's sandbox with no outbound network access for up to 30 seconds per
+                              execution and at most 5 executions per API call (the limit resets each turn),
+                              and each execution is billed as an AI Action to the connection's Google
+                              account rather than as Celigo AI credits.
+                            x-celigo-ai-guidance:
+                              - |-
+                                Add `codeExecution` only when the agent has a `_connectionId`. The save does
+                                not check the credential type, but every run and preview of an agent on
+                                Celigo-managed credentials is refused with `Code Execution requires a BYOK
+                                connection.` — switch the agent to a BYOK connection or leave the tool out.
+                              - |-
+                                Send the tool as `{type: codeExecution}` with no other key — any other key on
+                                it is rejected. Check that the chosen model supports code execution before
+                                adding it; the platform does not verify that at save and the UI hides the
+                                tool for models that lack it.
                           googleSearch:
                             type: object
                             description: Google Search configuration (empty object to enable)
@@ -22836,10 +22899,26 @@ components:
                               tool: Reference a reusable Celigo Tool resource.
                               mcp: Connect to an MCP server for additional external tools.
                               webSearch: Search the web for real-time information.
-                              codeExecution: 'Enable Anthropic''s built-in code-execution tool; carries no configuration block, send `{type: codeExecution}` only'
+                              codeExecution: 'Let the model write and run code in Anthropic''s sandbox on a BYOK agent (beta); carries no configuration block, send `{type: codeExecution}` only'
                             description: |-
                               Type of Claude tool. `codeExecution` is the Anthropic spelling — `code_execution`
-                              fails with 422 `enum`.
+                              fails with 422 `enum`. Code execution (beta on Anthropic) runs only on a BYOK
+                              agent and only on models that support it: the code runs per API call in
+                              Anthropic's sandbox (Python 3.11 with pandas, numpy and matplotlib) with no
+                              outbound network access and no state kept between turns, and each execution is
+                              billed as an AI Action to the connection's Anthropic account rather than as
+                              Celigo AI credits.
+                            x-celigo-ai-guidance:
+                              - |-
+                                Add `codeExecution` only when the agent has a `_connectionId`. The save does
+                                not check the credential type, but every run and preview of an agent on
+                                Celigo-managed credentials is refused with `Code Execution requires a BYOK
+                                connection.` — switch the agent to a BYOK connection or leave the tool out.
+                              - |-
+                                Send the tool as `{type: codeExecution}` with no other key — any other key on
+                                it is rejected. Check that the chosen model supports code execution before
+                                adding it; the platform does not verify that at save and the UI hides the
+                                tool for models that lack it.
                           tool:
                             type: object
                             description: Reference to a Celigo Tool resource, used when type is "tool".
@@ -23056,6 +23135,13 @@ components:
                   - deepseek
                   - cohere
                   - groq
+                  - together_ai
+                  - azure_ai
+                  - fireworks_ai
+                  - bedrock
+                  - nvidia_nim
+                  - ollama_chat
+                  - vertex_ai
             required:
               - provider
           then:
@@ -23075,8 +23161,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.
 
@@ -23128,26 +23216,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
@@ -23156,6 +23261,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: |-
@@ -24039,6 +24156,13 @@ components:
                   - deepseek
                   - cohere
                   - groq
+                  - together_ai
+                  - azure_ai
+                  - fireworks_ai
+                  - bedrock
+                  - nvidia_nim
+                  - ollama_chat
+                  - vertex_ai
             required:
               - provider
           then:
@@ -26166,7 +26290,7 @@ components:
             MongodbImport: MongoDB database import for document-based operations.
             DynamodbImport: Amazon DynamoDB import for NoSQL table operations.
             WrapperImport: Custom adaptor import built outside of Celigo (rarely used).
-            AiAgentImport: AI agent import using OpenAI, Gemini, Anthropic Claude, or a BYOK catalog provider (Mistral, xAI, Hugging Face, DeepSeek, Cohere, Groq) for data processing.
+            AiAgentImport: AI agent import using OpenAI, Gemini, Anthropic Claude, or a BYOK catalog provider (Mistral, xAI, Hugging Face, DeepSeek, Cohere, Groq, Together AI, Azure OpenAI, Fireworks AI, AWS Bedrock, NVIDIA NIM, Ollama Cloud, Google Vertex AI) for data processing.
             GuardrailImport: Safety and compliance check import for PII detection, moderation, or AI evaluation.
             FileSystemImport: Local or network file system import.
             ToolImport: Import that executes a reusable Celigo Tool resource.
@@ -30534,9 +30658,10 @@ components:
         json:
           type: object
           description: |-
-            Parsing settings for JSON files. Configure when type is "json". resourcePath locates the
-            array of records when they are nested inside a container object; malformed JSON fails
-            the entire file's processing.
+            Parsing settings for JSON files. Configure when type is "json". resourcePath selects the
+            record elements inside the document — the wildcard form (`*`, `rows[*]`) iterates an
+            array, while a path that stops at the array (or an empty path on a root array) yields
+            the whole array as one record; malformed JSON fails the entire file's processing.
 
             Required when type is json.
           x-celigo-ai-guidance:
@@ -30578,8 +30703,12 @@ components:
                   ]
                   ```
                   - Records are directly at the root as an array
-                  - No resourcePath needed (leave blank)
-                  - Most straightforward structure for processing
+                  - Set resourcePath to `*` (or `[*]`) so each element becomes a record
+                  - An empty resourcePath returns the entire array as ONE record — a large file then
+                    fails with `record_size_exceeded` instead of being split. The export form appends
+                    the wildcard itself when the attached sample file is 10 MB or smaller (why a blank
+                    path often works in the UI — a larger sample gets no wildcard and the blank path
+                    stands); a document sent through the API carries exactly the path it names
 
                   ### Container Object Pattern
                   ```json
@@ -30595,7 +30724,8 @@ components:
                   }
                   ```
                   - Records are in an array inside a container object
-                  - Requires resourcePath (e.g., "data")
+                  - Requires resourcePath with the element wildcard (e.g., "data[*]" or "data.*");
+                    "data" alone selects the array itself and yields it as one record
                   - Common in API responses with metadata
 
                   ### Nested Container Pattern
@@ -30614,13 +30744,20 @@ components:
                   }
                   ```
                   - Records are deeply nested in the hierarchy
-                  - Requires dot notation in resourcePath (e.g., "response.results")
+                  - Requires dot notation ending in the element wildcard (e.g., "response.results[*]")
                   - Common in complex API responses
             - |-
               ## ERROR PREVENTION
 
               - **Invalid Path**: Incorrectly specified resourcePath results in zero records found
-              - **Type Mismatch**: resourcePath must point to an array of objects for proper record processing
+              - **Array as one record**: a path that stops at the array (or an empty path on a root
+                array) yields the whole array as a single record; it fails `record_size_exceeded`
+                ("The size of a single record should not exceed 26214400 bytes. This may happen
+                because the Resource path is not set correctly") once the file passes 25 MiB — the
+                fix is the element wildcard (`*` / `path[*]`). A preSavePage hook cannot split the
+                record instead: the rejection happens while the file is parsed, before any page of
+                records exists for a hook to receive (an export with such a hook fails identically,
+                with zero pages generated)
               - **Empty Results**: If path resolves to null or non-existent field, no error is thrown but no records are processed
               - **Parsing Failures**: Malformed JSON will cause the entire file processing to fail
             - |-
@@ -30634,11 +30771,19 @@ components:
             resourcePath:
               type: string
               description: |-
-                Dot-notation path to the array of records within the JSON structure (e.g.
-                "response.data.customers"); leave empty when the file's root is already the record
-                array. The path must resolve to an array of objects — array indexing and wildcards
-                are not supported. A path that resolves to nothing produces zero records without
-                raising an error.
+                Dot-notation path that selects the record elements within the JSON document, ending
+                in the element wildcard — `*` when the file's root is the record array,
+                `response.data.customers[*]` (or `.customers.*`) when the array sits under a key. A
+                path that stops at the array — `response.data.customers`, or an empty path on a root
+                array — yields the whole array as a single record, which fails `record_size_exceeded`
+                once it exceeds 26,214,400 bytes. The export form appends the wildcard when the
+                attached sample file is 10 MB or smaller, so a path left blank in the UI often works
+                where the same document sent through the API — or a form with a larger sample — does
+                not. Array indexing and `$`-rooted JSONPath (`$[*]`,
+                `$.rows`) are not supported; a path that resolves to nothing produces zero records
+                without raising an error. This is the file parser's path only — the path to records
+                in an HTTP API response is the separate `http.response.resourcePath`, with its own
+                rules (a bare dot path such as `results.customers` selects the record array there).
               x-celigo-ai-guidance:
                 - |-
                   Specifies the path to the array of records within the JSON structure.
@@ -30647,18 +30792,18 @@ components:
                 - |-
                   ## BEHAVIOR
 
-                  - **Purpose**: Identifies where the array of records is located in the JSON structure
-                  - **Format**: Dot notation path to navigate nested objects (e.g., "data.records")
-                  - **When Empty**: System expects records to be at the root level as an array
-                  - **Result**: Array found at this path is processed as individual records
+                  - **Purpose**: Selects the elements that become records within the JSON structure
+                  - **Format**: Dot notation to navigate nested objects, ending in the element wildcard (e.g., "data.records[*]")
+                  - **When Empty**: The whole document is one record — a root object is that one record; a root array is NOT split (use `*` to split it)
+                  - **Result**: Each element the wildcard selects is processed as one record; a path that stops at the array yields the array as one record
                 - |-
                   ## PATH NOTATION GUIDELINES
 
                   ### Basic Path Patterns
 
-                  - **Root Level Array**: Leave empty or null when records are a direct array at root
-                  - **Single Level Nesting**: Use the property name (e.g., "data", "results", "items")
-                  - **Multi-Level Nesting**: Use dot notation (e.g., "response.data.items")
+                  - **Root Level Array**: `*` (or `[*]`) when records are a direct array at root
+                  - **Single Level Nesting**: The property name plus the wildcard (e.g., "data[*]", "results[*]", "items.*")
+                  - **Multi-Level Nesting**: Dot notation plus the wildcard (e.g., "response.data.items[*]")
 
                   ### Path Construction Rules
 
@@ -30667,13 +30812,14 @@ components:
                       - Each segment must be a valid property name in the JSON
 
                   2. **Target Requirements**:
-                      - The path MUST resolve to an array of objects
-                      - Each object in the array will be processed as one record
-                      - The array must be the final element in the path
+                      - The parser yields whatever the path selects as the record(s): to get one record per array element, the path MUST end in the element wildcard (`[*]` or `.*`)
+                      - A path that stops at the array ("data") selects the array itself and yields ONE record holding every element
+                      - A path that selects a single object ("response", "response.data") yields that object as one record — the shape for a file that IS one record
+                      - The wildcard iterates whatever it is applied to: on an OBJECT (`*` on a root object, "response.*") it yields one record per member value, not the object — apply it to arrays
 
                   3. **Limitations**:
                       - Array indexing is not supported in the path (e.g., "data[0]")
-                      - Wildcard selectors are not supported
+                      - `$`-rooted JSONPath is not supported ("$[*]", "$.data[*]" match nothing and yield zero records)
                       - Regular expressions are not supported
                 - |-
                   ## DETERMINATION STRATEGY FOR AI AGENTS
@@ -30689,20 +30835,21 @@ components:
 
                       | Source Type | Common Paths | Example |
                       |-------------|--------------|---------|
-                      | REST APIs | "data", "results", "items" | "data" |
-                      | Complex APIs | "response.data", "data.items" | "response.data" |
-                      | Database Exports | "rows", "records", "exports" | "rows" |
-                      | CRM Systems | "contacts", "accounts", "opportunities" | "contacts" |
-                      | Analytics APIs | "data.rows", "response.data.rows" | "data.rows" |
+                      | Root array file | "*" | "*" |
+                      | REST APIs | "data[*]", "results[*]", "items[*]" | "data[*]" |
+                      | Complex APIs | "response.data[*]", "data.items[*]" | "response.data[*]" |
+                      | Database Exports | "rows[*]", "records[*]", "exports[*]" | "rows[*]" |
+                      | CRM Systems | "contacts[*]", "accounts[*]", "opportunities[*]" | "contacts[*]" |
+                      | Analytics APIs | "data.rows[*]", "response.data.rows[*]" | "data.rows[*]" |
 
                   3. **Verification Approach**:
-                      - The path should resolve to an array (typically with square brackets in the JSON)
-                      - Each element in this array should represent one complete record
+                      - Preview the export: the parse stage must show one record per array element — a single record that is itself an array means the path stopped at the array
+                      - Each element should represent one complete record
                       - The array should not be a property array (like tags or categories)
                 - |-
                   ## IMPLEMENTATION EXAMPLES
 
-                  ### Root Array (No Path Needed)
+                  ### Root Array
 
                   JSON Structure:
                   ```json
@@ -30714,9 +30861,11 @@ components:
 
                   Configuration:
                   ```json
-                  "resourcePath": ""  // or omit entirely
+                  "resourcePath": "*"
                   ```
 
+                  An empty path (or omitting it) returns this array as ONE record rather than two.
+
                   ### Single-Level Nesting
 
                   JSON Structure:
@@ -30732,7 +30881,7 @@ components:
 
                   Configuration:
                   ```json
-                  "resourcePath": "orders"
+                  "resourcePath": "orders[*]"
                   ```
 
                   ### Multi-Level Nesting
@@ -30754,7 +30903,7 @@ components:
 
                   Configuration:
                   ```json
-                  "resourcePath": "response.data.customers"
+                  "resourcePath": "response.data.customers[*]"
                   ```
                 - |-
                   ## TROUBLESHOOTING INDICATORS
@@ -30762,6 +30911,8 @@ components:
                   If you encounter these issues, review the resourcePath setting:
 
                   - Export completes successfully but processes 0 records
+                  - `record_size_exceeded` — "The size of a single record should not exceed 26214400 bytes. This may happen because the Resource path is not set correctly": the path stopped at the array, so the whole file is one record; append the element wildcard (`*` for a root array, `path[*]` for a nested one) — a preSavePage hook cannot help: the record is rejected while the file is parsed, before any page exists for a hook to receive
+                  - A preview whose single record is itself an array of the expected objects (same cause, small file)
                   - "Cannot read property 'forEach' of undefined" errors
                   - "Expected array but got object/string/number" errors
                   - Records appear flattened or with unexpected structure
@@ -30773,10 +30924,11 @@ components:
                   - Document the expected JSON structure alongside the configuration
                   - For APIs with changing response structures, implement validation checks
               examples:
-                - data.orders
-                - response.results
-                - items
-                - data.customers.records
+                - '*'
+                - data.orders[*]
+                - response.results[*]
+                - items[*]
+                - data.customers.records.*
         xlsx:
           type: object
           description: |-
@@ -35184,7 +35336,7 @@ components:
     PathToRecords:
       type: string
       maxLength: 250
-      description: Path to the array of records inside each document or item fetched from the source; each array element is emitted as an individual record, which keeps records within the 5 MB page-size limit even when the source document exceeds it. Accepts dot notation (e.g. `data.orders`) or JSONPath for values starting with `$`, including unions (`$['orders','invoices'][*]`) and filter expressions (`$.items[?(@.qty>3)]`); a path that resolves to nothing emits zero records for that document or item. When omitted, each document or item is emitted as one record, exactly as before — HTTP and file-based exports configure this same capability through their existing `http.response.resourcePath` and `file.json`/`file.xml` `resourcePath` fields.
+      description: Path to the array of records inside each document or item fetched from the source; each array element is emitted as an individual record, which keeps records within the 5 MB page-size limit even when the source document exceeds it. Accepts dot notation (e.g. `data.orders`) or JSONPath for values starting with `$`, including unions (`$['orders','invoices'][*]`) and filter expressions (`$.items[?(@.qty>3)]`); a path that resolves to nothing emits zero records for that document or item. When omitted, each document or item is emitted as one record, exactly as before. HTTP exports configure the same capability through `http.response.resourcePath` with these same path rules; file-based exports configure it through `file.json`/`file.xml` `resourcePath`, where the JSON file parser follows its own rule — the path yields whatever it selects as the record, so it must end in the element wildcard (`*` for a root array, `data.orders[*]` under a key) to emit one record per element, and `$`-rooted JSONPath is not supported there.
       examples:
         - lineItems
         - order.lineItems

package/package.json

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

package/schemas.json

@@ -1,8 +1,8 @@
 {
 	"provenance": {
 		"repo": "celigo/integrator-api-specs",
-		"iasCommit": "6bca256a",
-		"generatedAt": "2026-10-30"
+		"iasCommit": "d89238ad",
+		"generatedAt": "2026-11-02"
 	},
 	"roots": {
 		"aiagent": 128,
@@ -66,13 +66,20 @@
 			],
 			"e": [
 				"anthropic",
+				"azure_ai",
+				"bedrock",
 				"cohere",
 				"deepseek",
+				"fireworks_ai",
 				"gemini",
 				"groq",
 				"huggingface",
 				"mistral",
+				"nvidia_nim",
+				"ollama_chat",
 				"openai",
+				"together_ai",
+				"vertex_ai",
 				"xai"
 			]
 		},