mixpeek 0.81.383 → 0.81.385

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/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.