@celigo/api-specs 0.2.33 → 0.2.35

package/dist/export.yml

@@ -7600,16 +7600,16 @@ components:
           description: |-
             Pins the export to a version of the published HTTP connector its connection is bound to
             (`connection.http._httpConnectorId`), so the UI renders that connector's endpoint form instead
-            of a hand-authored request. Persisted as sent on create and update; the value is not checked
-            against the connection's connector.
+            of a hand-authored request. Linked on save together with `_httpConnectorResourceId` and
+            `_httpConnectorEndpointId` — see that field for the rule.
         _httpConnectorResourceId:
           type: string
           format: objectId
           x-celigo-refModel: httpconnectorresources
           description: |-
             The connector resource (a group of related endpoints, such as Orders) that this export's
-            endpoint belongs to. Persisted as sent; take it from the same connector blueprint as
-            `_httpConnectorVersionId`.
+            endpoint belongs to. Linked on save together with `_httpConnectorEndpointId` — see that field
+            for the rule.
         sendAuthForFileDownloads:
           type: boolean
           description: When true, includes authentication headers when downloading files.
@@ -7618,24 +7618,28 @@ components:
           format: objectId
           x-celigo-refModel: httpconnectorendpoints
           description: |-
-            The connector endpoint this export calls, shown in the UI as the selected endpoint;
-            `relativeURI` and `method` should match that endpoint's definition. Persisted as sent on create
-            and update — the server does not verify that the endpoint belongs to the connection's connector,
-            so a mismatched id pins the export to the wrong endpoint form.
+            The connector endpoint this export calls, shown in the UI as the selected endpoint. On save the
+            platform derives it (with the version and resource ids) from `relativeURI` and `method` when
+            they match an endpoint of the connector the connection is bound to — path parameters, literal
+            ids and query strings still match — and replaces ids that belong to another connector. An id for
+            the connection's own connector is kept as sent even when the URI names a different endpoint;
+            when nothing matches, or the connection has no connector, whatever was sent is kept and nothing
+            is derived.
           x-celigo-ai-guidance:
             - |-
-              To build an export on a prebuilt connector instead of a hand-rolled HTTP request: find the
-              connector in `GET /v1/httpconnectors` (match `name` or `legacyId`); read
-              `GET /v1/httpconnectors/{_id}` for its `versions` (under `apis[]` for multi-API connectors);
-              list resources with `GET /v1/httpconnectors/{_id}/httpconnectorresources`, then that resource's
-              endpoints with `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/httpconnectorendpoints`
-              and one endpoint's `method` and `relativeURI` with
-              `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/{_id}`; copy that `relativeURI` and
-              `method` and set `_httpConnectorVersionId`, `_httpConnectorResourceId`, and
-              `_httpConnectorEndpointId` together. The export's connection must carry `http._httpConnectorId`
-              for the same connector; a top-level `_httpConnectorId` on the export itself is dropped. Omit all
-              three only when no published connector exists for the application. Verified against the live
-              API 2026-09-21.
+              To build an export on a prebuilt connector instead of a hand-rolled HTTP request, bind the
+              CONNECTION (`http._httpConnectorId` — find the connector in `GET /v1/httpconnectors` by `name`
+              or `legacyId`) and write the endpoint's `relativeURI` and `method`; the platform links the
+              export to that endpoint on save, so the three pointer fields may be omitted. Read the saved
+              export back: no pointers means the URI matched no endpoint of the connection's connector. Set
+              `_httpConnectorVersionId`, `_httpConnectorResourceId` and `_httpConnectorEndpointId` together
+              only to pin a same-connector endpoint the URI would not match. Endpoint discovery through the
+              published operations: `GET /v1/httpconnectors/{_id}` (`versions`, under `apis[]` for
+              multi-API connectors), `GET /v1/httpconnectors/{_id}/httpconnectorresources`,
+              `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/httpconnectorendpoints`, and
+              `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/{_id}` for an endpoint's `method` and
+              `relativeURI`. A top-level `_httpConnectorId` on the export itself is dropped. Verified against
+              the live API 2026-09-21.
       if:
         properties:
           type:

package/dist/import.yml

@@ -1667,21 +1667,24 @@ components:
             x-celigo-refModel: httpconnectorendpoints
           description: |-
             The connector endpoints this import calls, one per entry of `relativeURI` / `method` (for
-            example a CREATE and an UPDATE endpoint), shown in the UI as the selected endpoints. Persisted
-            as sent on create and update; the server does not verify that they belong to the connection's
-            connector.
+            example a CREATE and an UPDATE endpoint), shown in the UI as the selected endpoints. On save the
+            platform derives them (with the version and resource ids) from each `relativeURI` / `method`
+            pair that matches an endpoint of the connector the connection is bound to, and replaces ids
+            that belong to another connector; ids for the connection's own connector are kept as sent, and
+            when nothing matches, or the connection has no connector, whatever was sent is kept.
           x-celigo-ai-guidance:
             - |-
-              To build an import on a prebuilt connector: find the connector in `GET /v1/httpconnectors`; read
-              `GET /v1/httpconnectors/{_id}` for its `versions` (under `apis[]` for multi-API connectors); list
-              resources with `GET /v1/httpconnectors/{_id}/httpconnectorresources` and a resource's endpoints
-              with `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/httpconnectorendpoints`; read each
-              chosen endpoint's `method` and `relativeURI` with
-              `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/{_id}` and copy them into the positional
-              arrays, one endpoint per operation; set `_httpConnectorVersionId`, `_httpConnectorResourceId`, and
-              `_httpConnectorEndpointIds` together. Imports use this plural field; the singular
-              `_httpConnectorEndpointId` is dropped on write. The import's connection must carry
-              `http._httpConnectorId` for the same connector. Verified against the live API 2026-09-21.
+              To build an import on a prebuilt connector, bind the CONNECTION (`http._httpConnectorId`) and
+              write each operation's `relativeURI` and `method` into the positional arrays; the platform links
+              the import to those endpoints on save, so the pointer fields may be omitted. Read the saved
+              import back: missing entries mean a URI matched no endpoint of the connection's connector. Set
+              `_httpConnectorVersionId`, `_httpConnectorResourceId` and `_httpConnectorEndpointIds` together
+              only to pin same-connector endpoints the URIs would not match. Imports use this plural field;
+              the singular `_httpConnectorEndpointId` is dropped on write. Endpoint discovery through the
+              published operations: `GET /v1/httpconnectors/{_id}`, `…/{_id}/httpconnectorresources`,
+              `…/{_id}/{_httpConnectorResourceId}/httpconnectorendpoints`, and
+              `…/{_id}/{_httpConnectorResourceId}/{_id}` for an endpoint's `method` and `relativeURI`.
+              Verified against the live API 2026-09-21.
         blobFormat:
           type: string
           enum:
@@ -1870,16 +1873,17 @@ components:
               // shape; do not emit it deliberately.
               "relativeURI": ["[\"/customers/{{{data.0.id}}}\",\"/customers\"]"]
               ```
-              ⚠️ The API does NOT cross-check ``relativeURI`` / ``method`` against
-              the connector pointer fields (``_httpConnectorVersionId`` /
-              ``_httpConnectorResourceId`` / ``_httpConnectorEndpointIds``):
-              a save whose URI does not match the pinned endpoint keeps the
-              pointers exactly as sent (verified 2026-09-21 on create, on PUT,
-              after 60 s, and after a no-op re-save). The consistency is yours
-              to keep — copy each pinned endpoint's ``relativeURI`` and
-              ``method`` into these arrays position by position, so the
-              endpoint the pointers name and the request the runtime sends
-              are the same one. Get the URI shape right.
+              ⚠️ On save the platform derives the connector pointer fields
+              (``_httpConnectorVersionId`` / ``_httpConnectorResourceId`` /
+              ``_httpConnectorEndpointIds``) from each ``relativeURI`` /
+              ``method`` pair that matches an endpoint of the connector the
+              connection is bound to (path parameters and query strings still
+              match); pointers you send for that connector are kept, pointers
+              from another connector are replaced, and a URI that matches
+              nothing leaves whatever you sent in place — nothing is unset
+              (verified 2026-09-21 on create, on PUT, and after a re-save). Keep
+              each entry equal to the endpoint you mean so the pointer and the
+              request agree. Get the URI shape right.
           examples:
             - - /api/v1/customers
             - - /customers/{{{data.0.shopifyCustomerId}}}.json
@@ -1918,16 +1922,16 @@ components:
           description: |-
             Pins the import to a version of the published HTTP connector its connection is bound to
             (`connection.http._httpConnectorId`), so the UI renders that connector's endpoint forms instead
-            of hand-authored requests. Persisted as sent on create and update; not checked against the
-            connection's connector.
+            of hand-authored requests. Linked on save together with `_httpConnectorResourceId` and
+            `_httpConnectorEndpointIds` — see that field for the rule.
         _httpConnectorResourceId:
           type: string
           format: objectId
           x-celigo-refModel: httpconnectorresources
           description: |-
             The connector resource (a group of related endpoints, such as Orders) that this import's
-            endpoints belong to. Persisted as sent; take it from the same connector blueprint as
-            `_httpConnectorVersionId`.
+            endpoints belong to. Linked on save together with `_httpConnectorEndpointIds` — see that field
+            for the rule.
         _httpConnectorEndpointId:
           type: string
           format: objectId

package/dist/mcp-server.yml

@@ -502,6 +502,269 @@ paths:
           $ref: '#/components/responses/401-unauthorized'
         '404':
           $ref: '#/components/responses/404-not-found'
+  /v1/mcpservers/template/{_templateId}:
+    post:
+      x-internal: false
+      operationId: installMcpServerTemplate
+      tags:
+        - MCP Servers
+      summary: Install a published MCP server template
+      description: |-
+        Installs a published MCP-server marketplace template (a template whose
+        `type` is `mcpserver`). The request takes no parameters — the published
+        template ZIP is the source of truth for everything the install creates,
+        and there is no `connectionMap` (unlike the integration-template
+        install).
+
+        What the install creates depends on the template's contents, reported by
+        the response's `destination` envelope:
+
+        - **Prompt-only templates** (no tools) create the MCP server
+          immediately, disabled. `destination.resourceType` is `mcpservers`.
+        - **Tool-bearing templates** hand off to the Integration installer:
+          `destination.resourceType` is `integrations` and names an Integration
+          in install mode, where connection mapping and the remaining install
+          steps continue. The MCP server is created — disabled — by the
+          Integration's terminal install step, after the tools are cloned.
+
+        Integration templates do not install through this path — they use
+        `POST /v1/integrations/template/{_id}`. Each path rejects the other
+        class: this one returns 404 for a template that is not a published
+        MCP-server template, and the integration path rejects MCP-server
+        templates with a 400 `invalid_template` error.
+
+        Every request that reaches the platform starts a new install — there is
+        no idempotency key, so retrying after a timeout or ambiguous failure
+        creates a duplicate server or install-mode Integration. Duplicates are
+        kept apart by URI suffixing: each new server's `relativeURI` gets `-2`
+        through `-100` appended when the un-suffixed value is taken; once all
+        100 are in use the install fails with a 422 `invalid_value` error.
+
+        Requires the `install:published:template` permission.
+      x-celigo-ai-guidance:
+        - Send an empty JSON object as the body. Connection mapping for tool-bearing templates happens later, in the created Integration's install steps — never invent a connectionMap for this endpoint.
+        - Never retry this POST after a timeout or an ambiguous failure — a request that reached the platform already started an install, and a second request installs a duplicate.
+        - Branch the follow-up on destination.resourceType — "integrations" means install steps continue on the created Integration (its setup page); "mcpservers" means the disabled MCP server already exists and needs enabling and access before clients can use it.
+      parameters:
+        - name: _templateId
+          in: path
+          required: true
+          description: The published MCP-server template to install.
+          schema:
+            type: string
+            format: objectId
+            x-celigo-refModel: templates
+            examples:
+              - 6ab129aeb9e4547494c0667f
+      requestBody:
+        required: false
+        content:
+          application/json:
+            schema:
+              type: object
+              description: Empty object — the install takes no parameters.
+            examples:
+              empty:
+                summary: The install takes no parameters
+                value: {}
+      responses:
+        '201':
+          description: Installation started.
+          content:
+            application/json:
+              schema:
+                type: object
+                required:
+                  - destination
+                properties:
+                  destination:
+                    type: object
+                    description: The resource the install created first.
+                    required:
+                      - resourceType
+                      - resourceId
+                    properties:
+                      resourceType:
+                        type: string
+                        enum:
+                          - mcpservers
+                          - integrations
+                        x-enumDescriptions:
+                          mcpservers: The disabled MCP server created directly from a prompt-only template
+                          integrations: The install-mode Integration created for a tool-bearing template
+                        description: |-
+                          Which resource type the install created — determines
+                          where the caller continues the setup.
+                      resourceId:
+                        type: string
+                        format: objectId
+                        description: |-
+                          The created resource's ID, in the collection named by
+                          `resourceType`.
+              examples:
+                toolBearing:
+                  summary: Tool-bearing template — Integration in install mode
+                  value:
+                    destination:
+                      resourceType: integrations
+                      resourceId: 6ab130000000000000000d01
+                promptOnly:
+                  summary: Prompt-only template — disabled MCP server
+                  value:
+                    destination:
+                      resourceType: mcpservers
+                      resourceId: 6ab130000000000000000d02
+        '401':
+          $ref: '#/components/responses/401-unauthorized'
+        '403':
+          $ref: '#/components/responses/403-forbidden'
+        '404':
+          description: |-
+            No published MCP-server template with this ID. Integration templates
+            return 404 here too — they install via
+            `POST /v1/integrations/template/{_id}`.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              examples:
+                notFound:
+                  value:
+                    errors:
+                      - code: invalid_ref
+                        message: Template not found.
+        '422':
+          description: |-
+            The install was rejected before anything was created. As-built
+            cases: the template packages capabilities an MCP-server template
+            cannot carry (`invalid_template` — only tools and inline prompts
+            are portable), a packaged tool is missing or inaccessible
+            (`invalid_template`), or `relativeURI` de-duplication exhausted its
+            `-2`…`-100` suffixes (`invalid_value` — the account already holds
+            100 servers on that URI; delete or rename some before installing
+            again). None of these are retryable unchanged — and never retry
+            the POST blindly, since a request that reached the platform may
+            already have installed something.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              examples:
+                uriSuffixesExhausted:
+                  summary: relativeURI de-duplication exhausted
+                  value:
+                    errors:
+                      - code: invalid_value
+                        message: Unable to generate a unique relative URI for the MCP server from /installed-mcp-server.
+                unsupportedCapability:
+                  summary: Template packages non-portable capabilities
+                  value:
+                    errors:
+                      - code: invalid_template
+                        message: 'Installing an MCP server supports only tools and prompts. Unsupported: apis, resources.'
+  /v1/mcpservers/{_id}/template:
+    get:
+      x-internal: false
+      operationId: exportMcpServerTemplate
+      tags:
+        - MCP Servers
+      summary: Export an MCP server as a template ZIP
+      description: |-
+        Generates a template ZIP from the MCP server and returns a temporary
+        signed URL for downloading it. The ZIP contains the server document,
+        its inline prompts, its tools, and the resources those tools depend on
+        (exports, imports, connections, scripts) — a prompt-only server (no
+        tools) exports successfully. The ZIP is the artifact a publisher
+        uploads when authoring an MCP-server marketplace template; installing
+        that template recreates the server via
+        `POST /v1/mcpservers/template/{_templateId}`.
+
+        Only tools and inline prompts are portable. A server that publishes
+        APIs (`apis[]`) or file resources (`resources[]`) fails the export up
+        front with a 400 `invalid_template` error — no ZIP is generated;
+        nothing is stripped to make it succeed.
+
+        The signed URL expires after about 60 seconds — download promptly, and
+        call the endpoint again for a fresh URL rather than storing this one.
+
+        Requires the `create:mcpserver:template` permission.
+      parameters:
+        - name: _id
+          in: path
+          required: true
+          description: The MCP server to export.
+          schema:
+            type: string
+            format: objectId
+            x-celigo-refModel: mcpservers
+            examples:
+              - 69eb9fb5b4fc023618e490b8
+      responses:
+        '200':
+          description: Temporary signed URL for the generated ZIP.
+          content:
+            application/json:
+              schema:
+                type: object
+                required:
+                  - signedURL
+                  - key
+                properties:
+                  signedURL:
+                    type: string
+                    format: uri
+                    description: |-
+                      Time-limited download URL for the generated template ZIP —
+                      expires after about 60 seconds.
+                  key:
+                    type: string
+                    description: |-
+                      Storage key of the generated ZIP object — stable across
+                      the URL's expiry, useful for correlating repeated exports.
+              examples:
+                exported:
+                  summary: Signed URL for the generated ZIP
+                  value:
+                    signedURL: https://s3.amazonaws.com/templates/mcp-export/69eb9fb5b4fc023618e490b8.zip?X-Amz-Expires=60
+                    key: mcp-export/69eb9fb5b4fc023618e490b8.zip
+        '400':
+          description: |-
+            The server publishes capabilities a template cannot carry — only
+            tools and inline prompts are portable. Remove the APIs / file
+            resources (or export a server without them); retrying unchanged
+            fails identically.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              examples:
+                unsupportedCapability:
+                  summary: Server publishes APIs or file resources
+                  value:
+                    errors:
+                      - code: invalid_template
+                        message: 'Installing an MCP server supports only tools and prompts. Unsupported: apis, resources.'
+        '401':
+          $ref: '#/components/responses/401-unauthorized'
+        '403':
+          $ref: '#/components/responses/403-forbidden'
+        '404':
+          $ref: '#/components/responses/404-not-found'
+        '422':
+          description: |-
+            The export could not assemble a complete ZIP — a tool or its
+            backing integration is missing or not accessible to the caller.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              examples:
+                dependencyInvalid:
+                  summary: A tool dependency is missing or inaccessible
+                  value:
+                    errors:
+                      - code: invalid_template
+                        message: The MCP server template contains a missing or inaccessible tool dependency.
   /v1/mcpservers/{_id}/dependencies:
     get:
       x-internal: false

package/dist/tool.yml

@@ -10886,21 +10886,24 @@ components:
             x-celigo-refModel: httpconnectorendpoints
           description: |-
             The connector endpoints this import calls, one per entry of `relativeURI` / `method` (for
-            example a CREATE and an UPDATE endpoint), shown in the UI as the selected endpoints. Persisted
-            as sent on create and update; the server does not verify that they belong to the connection's
-            connector.
+            example a CREATE and an UPDATE endpoint), shown in the UI as the selected endpoints. On save the
+            platform derives them (with the version and resource ids) from each `relativeURI` / `method`
+            pair that matches an endpoint of the connector the connection is bound to, and replaces ids
+            that belong to another connector; ids for the connection's own connector are kept as sent, and
+            when nothing matches, or the connection has no connector, whatever was sent is kept.
           x-celigo-ai-guidance:
             - |-
-              To build an import on a prebuilt connector: find the connector in `GET /v1/httpconnectors`; read
-              `GET /v1/httpconnectors/{_id}` for its `versions` (under `apis[]` for multi-API connectors); list
-              resources with `GET /v1/httpconnectors/{_id}/httpconnectorresources` and a resource's endpoints
-              with `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/httpconnectorendpoints`; read each
-              chosen endpoint's `method` and `relativeURI` with
-              `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/{_id}` and copy them into the positional
-              arrays, one endpoint per operation; set `_httpConnectorVersionId`, `_httpConnectorResourceId`, and
-              `_httpConnectorEndpointIds` together. Imports use this plural field; the singular
-              `_httpConnectorEndpointId` is dropped on write. The import's connection must carry
-              `http._httpConnectorId` for the same connector. Verified against the live API 2026-09-21.
+              To build an import on a prebuilt connector, bind the CONNECTION (`http._httpConnectorId`) and
+              write each operation's `relativeURI` and `method` into the positional arrays; the platform links
+              the import to those endpoints on save, so the pointer fields may be omitted. Read the saved
+              import back: missing entries mean a URI matched no endpoint of the connection's connector. Set
+              `_httpConnectorVersionId`, `_httpConnectorResourceId` and `_httpConnectorEndpointIds` together
+              only to pin same-connector endpoints the URIs would not match. Imports use this plural field;
+              the singular `_httpConnectorEndpointId` is dropped on write. Endpoint discovery through the
+              published operations: `GET /v1/httpconnectors/{_id}`, `…/{_id}/httpconnectorresources`,
+              `…/{_id}/{_httpConnectorResourceId}/httpconnectorendpoints`, and
+              `…/{_id}/{_httpConnectorResourceId}/{_id}` for an endpoint's `method` and `relativeURI`.
+              Verified against the live API 2026-09-21.
         blobFormat:
           type: string
           enum:
@@ -11089,16 +11092,17 @@ components:
               // shape; do not emit it deliberately.
               "relativeURI": ["[\"/customers/{{{data.0.id}}}\",\"/customers\"]"]
               ```
-              ⚠️ The API does NOT cross-check ``relativeURI`` / ``method`` against
-              the connector pointer fields (``_httpConnectorVersionId`` /
-              ``_httpConnectorResourceId`` / ``_httpConnectorEndpointIds``):
-              a save whose URI does not match the pinned endpoint keeps the
-              pointers exactly as sent (verified 2026-09-21 on create, on PUT,
-              after 60 s, and after a no-op re-save). The consistency is yours
-              to keep — copy each pinned endpoint's ``relativeURI`` and
-              ``method`` into these arrays position by position, so the
-              endpoint the pointers name and the request the runtime sends
-              are the same one. Get the URI shape right.
+              ⚠️ On save the platform derives the connector pointer fields
+              (``_httpConnectorVersionId`` / ``_httpConnectorResourceId`` /
+              ``_httpConnectorEndpointIds``) from each ``relativeURI`` /
+              ``method`` pair that matches an endpoint of the connector the
+              connection is bound to (path parameters and query strings still
+              match); pointers you send for that connector are kept, pointers
+              from another connector are replaced, and a URI that matches
+              nothing leaves whatever you sent in place — nothing is unset
+              (verified 2026-09-21 on create, on PUT, and after a re-save). Keep
+              each entry equal to the endpoint you mean so the pointer and the
+              request agree. Get the URI shape right.
           examples:
             - - /api/v1/customers
             - - /customers/{{{data.0.shopifyCustomerId}}}.json
@@ -11137,16 +11141,16 @@ components:
           description: |-
             Pins the import to a version of the published HTTP connector its connection is bound to
             (`connection.http._httpConnectorId`), so the UI renders that connector's endpoint forms instead
-            of hand-authored requests. Persisted as sent on create and update; not checked against the
-            connection's connector.
+            of hand-authored requests. Linked on save together with `_httpConnectorResourceId` and
+            `_httpConnectorEndpointIds` — see that field for the rule.
         _httpConnectorResourceId:
           type: string
           format: objectId
           x-celigo-refModel: httpconnectorresources
           description: |-
             The connector resource (a group of related endpoints, such as Orders) that this import's
-            endpoints belong to. Persisted as sent; take it from the same connector blueprint as
-            `_httpConnectorVersionId`.
+            endpoints belong to. Linked on save together with `_httpConnectorEndpointIds` — see that field
+            for the rule.
         _httpConnectorEndpointId:
           type: string
           format: objectId
@@ -28159,16 +28163,16 @@ components:
           description: |-
             Pins the export to a version of the published HTTP connector its connection is bound to
             (`connection.http._httpConnectorId`), so the UI renders that connector's endpoint form instead
-            of a hand-authored request. Persisted as sent on create and update; the value is not checked
-            against the connection's connector.
+            of a hand-authored request. Linked on save together with `_httpConnectorResourceId` and
+            `_httpConnectorEndpointId` — see that field for the rule.
         _httpConnectorResourceId:
           type: string
           format: objectId
           x-celigo-refModel: httpconnectorresources
           description: |-
             The connector resource (a group of related endpoints, such as Orders) that this export's
-            endpoint belongs to. Persisted as sent; take it from the same connector blueprint as
-            `_httpConnectorVersionId`.
+            endpoint belongs to. Linked on save together with `_httpConnectorEndpointId` — see that field
+            for the rule.
         sendAuthForFileDownloads:
           type: boolean
           description: When true, includes authentication headers when downloading files.
@@ -28177,24 +28181,28 @@ components:
           format: objectId
           x-celigo-refModel: httpconnectorendpoints
           description: |-
-            The connector endpoint this export calls, shown in the UI as the selected endpoint;
-            `relativeURI` and `method` should match that endpoint's definition. Persisted as sent on create
-            and update — the server does not verify that the endpoint belongs to the connection's connector,
-            so a mismatched id pins the export to the wrong endpoint form.
+            The connector endpoint this export calls, shown in the UI as the selected endpoint. On save the
+            platform derives it (with the version and resource ids) from `relativeURI` and `method` when
+            they match an endpoint of the connector the connection is bound to — path parameters, literal
+            ids and query strings still match — and replaces ids that belong to another connector. An id for
+            the connection's own connector is kept as sent even when the URI names a different endpoint;
+            when nothing matches, or the connection has no connector, whatever was sent is kept and nothing
+            is derived.
           x-celigo-ai-guidance:
             - |-
-              To build an export on a prebuilt connector instead of a hand-rolled HTTP request: find the
-              connector in `GET /v1/httpconnectors` (match `name` or `legacyId`); read
-              `GET /v1/httpconnectors/{_id}` for its `versions` (under `apis[]` for multi-API connectors);
-              list resources with `GET /v1/httpconnectors/{_id}/httpconnectorresources`, then that resource's
-              endpoints with `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/httpconnectorendpoints`
-              and one endpoint's `method` and `relativeURI` with
-              `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/{_id}`; copy that `relativeURI` and
-              `method` and set `_httpConnectorVersionId`, `_httpConnectorResourceId`, and
-              `_httpConnectorEndpointId` together. The export's connection must carry `http._httpConnectorId`
-              for the same connector; a top-level `_httpConnectorId` on the export itself is dropped. Omit all
-              three only when no published connector exists for the application. Verified against the live
-              API 2026-09-21.
+              To build an export on a prebuilt connector instead of a hand-rolled HTTP request, bind the
+              CONNECTION (`http._httpConnectorId` — find the connector in `GET /v1/httpconnectors` by `name`
+              or `legacyId`) and write the endpoint's `relativeURI` and `method`; the platform links the
+              export to that endpoint on save, so the three pointer fields may be omitted. Read the saved
+              export back: no pointers means the URI matched no endpoint of the connection's connector. Set
+              `_httpConnectorVersionId`, `_httpConnectorResourceId` and `_httpConnectorEndpointId` together
+              only to pin a same-connector endpoint the URI would not match. Endpoint discovery through the
+              published operations: `GET /v1/httpconnectors/{_id}` (`versions`, under `apis[]` for
+              multi-API connectors), `GET /v1/httpconnectors/{_id}/httpconnectorresources`,
+              `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/httpconnectorendpoints`, and
+              `GET /v1/httpconnectors/{_id}/{_httpConnectorResourceId}/{_id}` for an endpoint's `method` and
+              `relativeURI`. A top-level `_httpConnectorId` on the export itself is dropped. Verified against
+              the live API 2026-09-21.
       if:
         properties:
           type:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celigo/api-specs",
-  "version": "0.2.33",
+  "version": "0.2.35",
   "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": "99c0989",
+		"iasCommit": "1b6c8d6",
 		"generatedAt": "2026-09-21"
 	},
 	"roots": {