mixpeek 0.81.382 → 0.81.384

package/dist/api/adhoc-retrievers-api.d.ts

@@ -22,7 +22,7 @@ import type { ListAdhocExecutionsResponse } from '../models';
  */
 export declare const AdhocRetrieversApiAxiosParamCreator: (configuration?: Configuration) => {
     /**
-     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching (MI-4726): ad-hoc executions are ALWAYS fresh — this route never reads or writes the execute/stage cache (``cache_status`` is always ``disabled``), so there is no ``skip_cache`` parameter and none is needed. If you want caching with an explicit opt-out, persist the retriever (``POST /retrievers``) and call its ``/retrievers/{id}/execute`` route, which accepts ``skip_cache`` in both the query string and the body.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
+     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching: this route does not use the retriever-level execute cache, so ``cache_status`` is always ``disabled`` and there is no ``skip_cache`` parameter.  That does NOT mean every response is freshly computed. Individual stages keep their own caches, which this route cannot switch off, so a stage may serve a cached result and report ``cache_hit: true`` under ``stage_statistics.stages[*]`` on a response whose top-level ``cache_status`` reads ``disabled``. The two fields describe different caches. If you need a guaranteed fresh execution, persist the retriever (``POST /retrievers``) and call ``/retrievers/{id}/execute`` with ``skip_cache``, which this route lacks and which does reach the stages.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
      * @summary Execute Adhoc Retriever
      * @param {AdhocExecuteRequest} adhocExecuteRequest
      * @param {boolean} [returnPresignedUrls]
@@ -62,7 +62,7 @@ export declare const AdhocRetrieversApiAxiosParamCreator: (configuration?: Confi
  */
 export declare const AdhocRetrieversApiFp: (configuration?: Configuration) => {
     /**
-     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching (MI-4726): ad-hoc executions are ALWAYS fresh — this route never reads or writes the execute/stage cache (``cache_status`` is always ``disabled``), so there is no ``skip_cache`` parameter and none is needed. If you want caching with an explicit opt-out, persist the retriever (``POST /retrievers``) and call its ``/retrievers/{id}/execute`` route, which accepts ``skip_cache`` in both the query string and the body.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
+     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching: this route does not use the retriever-level execute cache, so ``cache_status`` is always ``disabled`` and there is no ``skip_cache`` parameter.  That does NOT mean every response is freshly computed. Individual stages keep their own caches, which this route cannot switch off, so a stage may serve a cached result and report ``cache_hit: true`` under ``stage_statistics.stages[*]`` on a response whose top-level ``cache_status`` reads ``disabled``. The two fields describe different caches. If you need a guaranteed fresh execution, persist the retriever (``POST /retrievers``) and call ``/retrievers/{id}/execute`` with ``skip_cache``, which this route lacks and which does reach the stages.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
      * @summary Execute Adhoc Retriever
      * @param {AdhocExecuteRequest} adhocExecuteRequest
      * @param {boolean} [returnPresignedUrls]
@@ -102,7 +102,7 @@ export declare const AdhocRetrieversApiFp: (configuration?: Configuration) => {
  */
 export declare const AdhocRetrieversApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
     /**
-     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching (MI-4726): ad-hoc executions are ALWAYS fresh — this route never reads or writes the execute/stage cache (``cache_status`` is always ``disabled``), so there is no ``skip_cache`` parameter and none is needed. If you want caching with an explicit opt-out, persist the retriever (``POST /retrievers``) and call its ``/retrievers/{id}/execute`` route, which accepts ``skip_cache`` in both the query string and the body.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
+     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching: this route does not use the retriever-level execute cache, so ``cache_status`` is always ``disabled`` and there is no ``skip_cache`` parameter.  That does NOT mean every response is freshly computed. Individual stages keep their own caches, which this route cannot switch off, so a stage may serve a cached result and report ``cache_hit: true`` under ``stage_statistics.stages[*]`` on a response whose top-level ``cache_status`` reads ``disabled``. The two fields describe different caches. If you need a guaranteed fresh execution, persist the retriever (``POST /retrievers``) and call ``/retrievers/{id}/execute`` with ``skip_cache``, which this route lacks and which does reach the stages.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
      * @summary Execute Adhoc Retriever
      * @param {AdhocRetrieversApiExecuteAdhocRetrieverRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -233,7 +233,7 @@ export interface AdhocRetrieversApiListAdhocExecutionsRetrieversRequest {
  */
 export declare class AdhocRetrieversApi extends BaseAPI {
     /**
-     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching (MI-4726): ad-hoc executions are ALWAYS fresh — this route never reads or writes the execute/stage cache (``cache_status`` is always ``disabled``), so there is no ``skip_cache`` parameter and none is needed. If you want caching with an explicit opt-out, persist the retriever (``POST /retrievers``) and call its ``/retrievers/{id}/execute`` route, which accepts ``skip_cache`` in both the query string and the body.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
+     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching: this route does not use the retriever-level execute cache, so ``cache_status`` is always ``disabled`` and there is no ``skip_cache`` parameter.  That does NOT mean every response is freshly computed. Individual stages keep their own caches, which this route cannot switch off, so a stage may serve a cached result and report ``cache_hit: true`` under ``stage_statistics.stages[*]`` on a response whose top-level ``cache_status`` reads ``disabled``. The two fields describe different caches. If you need a guaranteed fresh execution, persist the retriever (``POST /retrievers``) and call ``/retrievers/{id}/execute`` with ``skip_cache``, which this route lacks and which does reach the stages.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
      * @summary Execute Adhoc Retriever
      * @param {AdhocRetrieversApiExecuteAdhocRetrieverRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.

package/dist/api/retrievers-api.d.ts

@@ -176,7 +176,7 @@ export declare const RetrieversApiAxiosParamCreator: (configuration?: Configurat
      */
     listRetrieversGet: (limit?: number, pageSize?: number, offset?: number, page?: number, cursor?: string, nextCursor?: string, after?: string, includeTotal?: boolean, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them.  input_schema and budget_limits remain immutable; use POST /{retriever_id}/clone.
+     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them. - input_schema: NON-BREAKING evolution only (add default/examples/description   to a field, add a new optional field). Breaking changes — removing a field,   changing a type, making a field newly required — are rejected with 422   naming each one; clone the retriever for those.  budget_limits remains immutable; use POST /{retriever_id}/clone.
      * @summary Patch Retriever
      * @param {string} retrieverId Retriever ID or name.
      * @param {PatchRetrieverRequest} patchRetrieverRequest
@@ -337,7 +337,7 @@ export declare const RetrieversApiFp: (configuration?: Configuration) => {
      */
     listRetrieversGet(limit?: number, pageSize?: number, offset?: number, page?: number, cursor?: string, nextCursor?: string, after?: string, includeTotal?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListRetrieversResponse>>;
     /**
-     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them.  input_schema and budget_limits remain immutable; use POST /{retriever_id}/clone.
+     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them. - input_schema: NON-BREAKING evolution only (add default/examples/description   to a field, add a new optional field). Breaking changes — removing a field,   changing a type, making a field newly required — are rejected with 422   naming each one; clone the retriever for those.  budget_limits remains immutable; use POST /{retriever_id}/clone.
      * @summary Patch Retriever
      * @param {string} retrieverId Retriever ID or name.
      * @param {PatchRetrieverRequest} patchRetrieverRequest
@@ -460,7 +460,7 @@ export declare const RetrieversApiFactory: (configuration?: Configuration, baseP
      */
     listRetrieversGet(requestParameters?: RetrieversApiListRetrieversGetRequest, options?: RawAxiosRequestConfig): AxiosPromise<ListRetrieversResponse>;
     /**
-     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them.  input_schema and budget_limits remain immutable; use POST /{retriever_id}/clone.
+     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them. - input_schema: NON-BREAKING evolution only (add default/examples/description   to a field, add a new optional field). Breaking changes — removing a field,   changing a type, making a field newly required — are rejected with 422   naming each one; clone the retriever for those.  budget_limits remains immutable; use POST /{retriever_id}/clone.
      * @summary Patch Retriever
      * @param {RetrieversApiPatchRetrieverRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -1013,7 +1013,7 @@ export declare class RetrieversApi extends BaseAPI {
      */
     listRetrieversGet(requestParameters?: RetrieversApiListRetrieversGetRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ListRetrieversResponse, any, {}>>;
     /**
-     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them.  input_schema and budget_limits remain immutable; use POST /{retriever_id}/clone.
+     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them. - input_schema: NON-BREAKING evolution only (add default/examples/description   to a field, add a new optional field). Breaking changes — removing a field,   changing a type, making a field newly required — are rejected with 422   naming each one; clone the retriever for those.  budget_limits remains immutable; use POST /{retriever_id}/clone.
      * @summary Patch Retriever
      * @param {RetrieversApiPatchRetrieverRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.

package/dist/index.js

@@ -119,7 +119,7 @@ var createRequestFunction = function(axiosArgs, globalAxios100, BASE_PATH2, conf
 var AdhocRetrieversApiAxiosParamCreator = function(configuration) {
   return {
     /**
-     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching (MI-4726): ad-hoc executions are ALWAYS fresh — this route never reads or writes the execute/stage cache (``cache_status`` is always ``disabled``), so there is no ``skip_cache`` parameter and none is needed. If you want caching with an explicit opt-out, persist the retriever (``POST /retrievers``) and call its ``/retrievers/{id}/execute`` route, which accepts ``skip_cache`` in both the query string and the body.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
+     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching: this route does not use the retriever-level execute cache, so ``cache_status`` is always ``disabled`` and there is no ``skip_cache`` parameter.  That does NOT mean every response is freshly computed. Individual stages keep their own caches, which this route cannot switch off, so a stage may serve a cached result and report ``cache_hit: true`` under ``stage_statistics.stages[*]`` on a response whose top-level ``cache_status`` reads ``disabled``. The two fields describe different caches. If you need a guaranteed fresh execution, persist the retriever (``POST /retrievers``) and call ``/retrievers/{id}/execute`` with ``skip_cache``, which this route lacks and which does reach the stages.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
      * @summary Execute Adhoc Retriever
      * @param {AdhocExecuteRequest} adhocExecuteRequest 
      * @param {boolean} [returnPresignedUrls] 
@@ -251,7 +251,7 @@ var AdhocRetrieversApiFp = function(configuration) {
   const localVarAxiosParamCreator = AdhocRetrieversApiAxiosParamCreator(configuration);
   return {
     /**
-     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching (MI-4726): ad-hoc executions are ALWAYS fresh — this route never reads or writes the execute/stage cache (``cache_status`` is always ``disabled``), so there is no ``skip_cache`` parameter and none is needed. If you want caching with an explicit opt-out, persist the retriever (``POST /retrievers``) and call its ``/retrievers/{id}/execute`` route, which accepts ``skip_cache`` in both the query string and the body.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
+     * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching: this route does not use the retriever-level execute cache, so ``cache_status`` is always ``disabled`` and there is no ``skip_cache`` parameter.  That does NOT mean every response is freshly computed. Individual stages keep their own caches, which this route cannot switch off, so a stage may serve a cached result and report ``cache_hit: true`` under ``stage_statistics.stages[*]`` on a response whose top-level ``cache_status`` reads ``disabled``. The two fields describe different caches. If you need a guaranteed fresh execution, persist the retriever (``POST /retrievers``) and call ``/retrievers/{id}/execute`` with ``skip_cache``, which this route lacks and which does reach the stages.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
      * @summary Execute Adhoc Retriever
      * @param {AdhocExecuteRequest} adhocExecuteRequest 
      * @param {boolean} [returnPresignedUrls] 
@@ -303,7 +303,7 @@ var AdhocRetrieversApiFp = function(configuration) {
 };
 var AdhocRetrieversApi = class extends BaseAPI {
   /**
-   * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching (MI-4726): ad-hoc executions are ALWAYS fresh — this route never reads or writes the execute/stage cache (``cache_status`` is always ``disabled``), so there is no ``skip_cache`` parameter and none is needed. If you want caching with an explicit opt-out, persist the retriever (``POST /retrievers``) and call its ``/retrievers/{id}/execute`` route, which accepts ``skip_cache`` in both the query string and the body.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
+   * Execute a retriever ad-hoc without persisting the configuration.  This endpoint allows you to execute a retriever without saving it to the database. Useful for one-time queries, testing configurations, or temporary searches.  Caching: this route does not use the retriever-level execute cache, so ``cache_status`` is always ``disabled`` and there is no ``skip_cache`` parameter.  That does NOT mean every response is freshly computed. Individual stages keep their own caches, which this route cannot switch off, so a stage may serve a cached result and report ``cache_hit: true`` under ``stage_statistics.stages[*]`` on a response whose top-level ``cache_status`` reads ``disabled``. The two fields describe different caches. If you need a guaranteed fresh execution, persist the retriever (``POST /retrievers``) and call ``/retrievers/{id}/execute`` with ``skip_cache``, which this route lacks and which does reach the stages.  Streaming Execution (stream=True):     Response uses Server-Sent Events (SSE) format with Content-Type: text/event-stream.     Each stage emits events as it executes, formatted as: data: {json}\\n\\n      Event Types (StreamEventType):     - stage_start: Emitted when a stage begins (includes stage_name, stage_index, total_stages)     - stage_complete: Emitted when a stage finishes (includes documents, statistics, budget_used)     - stage_error: Emitted if a stage fails (includes error message)     - execution_complete: Final event with complete results and pagination     - execution_error: Emitted if entire execution fails      StreamStageEvent Fields:     - event_type: Type of event     - execution_id: Unique execution identifier     - stage_name/stage_index/total_stages: Stage progress info     - documents: Intermediate results (stage_complete only)     - statistics: Stage metrics (duration_ms, input_count, output_count, efficiency)     - budget_used: Cumulative consumption (credits_used, time_elapsed_ms, tokens_used)      Response Headers:     - Content-Type: text/event-stream     - Cache-Control: no-cache     - Connection: keep-alive     - X-Execution-Mode: adhoc  Standard Execution (stream=False, default):     - Returns ExecuteRetrieverResponse after all stages complete     - Includes X-Execution-Mode: adhoc header     - execution_metadata.retriever_persisted = False  Use Cases:     - One-time queries without saving retriever configuration     - Testing stage configurations before persisting     - Dynamic retrieval with varying parameters     - Real-time progress tracking with streaming
    * @summary Execute Adhoc Retriever
    * @param {AdhocRetrieversApiExecuteAdhocRetrieverRequest} requestParameters Request parameters.
    * @param {*} [options] Override http request option.
@@ -17157,7 +17157,7 @@ var RetrieversApiAxiosParamCreator = function(configuration) {
       };
     },
     /**
-     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them.  input_schema and budget_limits remain immutable; use POST /{retriever_id}/clone.
+     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them. - input_schema: NON-BREAKING evolution only (add default/examples/description   to a field, add a new optional field). Breaking changes — removing a field,   changing a type, making a field newly required — are rejected with 422   naming each one; clone the retriever for those.  budget_limits remains immutable; use POST /{retriever_id}/clone.
      * @summary Patch Retriever
      * @param {string} retrieverId Retriever ID or name.
      * @param {PatchRetrieverRequest} patchRetrieverRequest 
@@ -17401,7 +17401,7 @@ var RetrieversApiFp = function(configuration) {
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios6__default.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
     /**
-     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them.  input_schema and budget_limits remain immutable; use POST /{retriever_id}/clone.
+     * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them. - input_schema: NON-BREAKING evolution only (add default/examples/description   to a field, add a new optional field). Breaking changes — removing a field,   changing a type, making a field newly required — are rejected with 422   naming each one; clone the retriever for those.  budget_limits remains immutable; use POST /{retriever_id}/clone.
      * @summary Patch Retriever
      * @param {string} retrieverId Retriever ID or name.
      * @param {PatchRetrieverRequest} patchRetrieverRequest 
@@ -17561,7 +17561,7 @@ var RetrieversApi = class extends BaseAPI {
     return RetrieversApiFp(this.configuration).listRetrieversGet(requestParameters.limit, requestParameters.pageSize, requestParameters.offset, requestParameters.page, requestParameters.cursor, requestParameters.nextCursor, requestParameters.after, requestParameters.includeTotal, options).then((request) => request(this.axios, this.basePath));
   }
   /**
-   * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them.  input_schema and budget_limits remain immutable; use POST /{retriever_id}/clone.
+   * Update a retriever\'s metadata.  Editable fields: - name, description, tags, display_config: metadata - collection_identifiers: re-points + re-validates stage feature URIs - stages (BACKE-1287): edit stages in place on an UNPUBLISHED retriever   (change a filter/operator/rerank without clone+repoint+delete); the full   stage list is replaced + re-validated as on create. A PUBLISHED retriever\'s   stages stay immutable — clone or unpublish to change them. - input_schema: NON-BREAKING evolution only (add default/examples/description   to a field, add a new optional field). Breaking changes — removing a field,   changing a type, making a field newly required — are rejected with 422   naming each one; clone the retriever for those.  budget_limits remains immutable; use POST /{retriever_id}/clone.
    * @summary Patch Retriever
    * @param {RetrieversApiPatchRetrieverRequest} requestParameters Request parameters.
    * @param {*} [options] Override http request option.