@mistralai/mistralai 2.2.6 → 2.3.0

package/src/sdk/accesses.ts

@@ -55,7 +55,7 @@ export class Accesses extends ClientSDK {
   async delete(
     request: operations.LibrariesShareDeleteV1Request,
     options?: RequestOptions,
-  ): Promise<components.Sharing> {
+  ): Promise<components.Sharing | undefined> {
     return unwrapAsync(betaLibrariesAccessesDelete(
       this,
       request,

package/src/sdk/deployments.ts

@@ -4,7 +4,10 @@
  */
 
 import { workflowsDeploymentsGetDeployment } from "../funcs/workflowsDeploymentsGetDeployment.js";
+import { workflowsDeploymentsGetDeploymentLogs } from "../funcs/workflowsDeploymentsGetDeploymentLogs.js";
 import { workflowsDeploymentsListDeployments } from "../funcs/workflowsDeploymentsListDeployments.js";
+import { workflowsDeploymentsStreamDeploymentLogs } from "../funcs/workflowsDeploymentsStreamDeploymentLogs.js";
+import { EventStream } from "../lib/event-streams.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
@@ -40,4 +43,44 @@ export class Deployments extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Get Deployment Logs
+   *
+   * @remarks
+   * Retrieve logs for a deployment (across all of its workers).
+   *
+   * Use `after`/`before`/`order` on the first request to set the time range and sort order; for
+   * the next pages pass the `cursor` from the previous response (it remembers the range and order).
+   */
+  async getDeploymentLogs(
+    request: operations.GetDeploymentLogsRequest,
+    options?: RequestOptions,
+  ): Promise<components.DeploymentLogSearchResponse> {
+    return unwrapAsync(workflowsDeploymentsGetDeploymentLogs(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Stream Deployment Logs
+   *
+   * @remarks
+   * Stream logs for a deployment (all of its workers) via SSE.
+   *
+   * Resume cursor comes from the `Last-Event-ID` header or `last_event_id` query param (header wins)
+   * and takes precedence over `after`; omit all to tail from the deployment start.
+   */
+  async streamDeploymentLogs(
+    request: operations.StreamDeploymentLogsRequest,
+    options?: RequestOptions,
+  ): Promise<EventStream<operations.StreamDeploymentLogsResponseBody>> {
+    return unwrapAsync(workflowsDeploymentsStreamDeploymentLogs(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/src/sdk/executions.ts

@@ -10,6 +10,7 @@ import { workflowsExecutionsGetWorkflowExecution } from "../funcs/workflowsExecu
 import { workflowsExecutionsGetWorkflowExecutionHistory } from "../funcs/workflowsExecutionsGetWorkflowExecutionHistory.js";
 import { workflowsExecutionsGetWorkflowExecutionLogs } from "../funcs/workflowsExecutionsGetWorkflowExecutionLogs.js";
 import { workflowsExecutionsGetWorkflowExecutionTraceEvents } from "../funcs/workflowsExecutionsGetWorkflowExecutionTraceEvents.js";
+import { workflowsExecutionsGetWorkflowExecutionTraceInfo } from "../funcs/workflowsExecutionsGetWorkflowExecutionTraceInfo.js";
 import { workflowsExecutionsGetWorkflowExecutionTraceOtel } from "../funcs/workflowsExecutionsGetWorkflowExecutionTraceOtel.js";
 import { workflowsExecutionsGetWorkflowExecutionTraceSummary } from "../funcs/workflowsExecutionsGetWorkflowExecutionTraceSummary.js";
 import { workflowsExecutionsQueryWorkflowExecution } from "../funcs/workflowsExecutionsQueryWorkflowExecution.js";
@@ -174,6 +175,20 @@ export class Executions extends ClientSDK {
     ));
   }
 
+  /**
+   * Get Workflow Execution Trace Info
+   */
+  async getWorkflowExecutionTraceInfo(
+    request: operations.GetWorkflowExecutionTraceInfoRequest,
+    options?: RequestOptions,
+  ): Promise<components.ExecutionTraceInfoResponse> {
+    return unwrapAsync(workflowsExecutionsGetWorkflowExecutionTraceInfo(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Get Workflow Execution Trace Otel
    */
@@ -238,12 +253,10 @@ export class Executions extends ClientSDK {
    * Get Workflow Execution Logs
    *
    * @remarks
-   * Retrieve logs for a workflow execution from Dora.
+   * Retrieve logs for a workflow execution.
    *
-   * First page sets the window via `after`/`before` (default: execution start through now, both
-   * widened by a margin so the bounds still prune partitions); later pages pass `cursor`, which
-   * carries both the window and the sort order (so `after`/`before`/`order` are then ignored —
-   * the order is fixed at the first page so a client can't flip direction mid-pagination).
+   * Use `after`/`before`/`order` on the first request to set the time range and sort order; for
+   * the next pages pass the `cursor` from the previous response (it remembers the range and order).
    */
   async getWorkflowExecutionLogs(
     request: operations.GetWorkflowExecutionLogsRequest,
@@ -262,8 +275,8 @@ export class Executions extends ClientSDK {
    * @remarks
    * Stream logs for a workflow execution via SSE.
    *
-   * If `last_event_id` is set it resumes from that cursor and takes precedence over `after`;
-   * otherwise `after` sets a fresh stream's start point (omit both to tail from the execution start).
+   * Resume cursor comes from the `Last-Event-ID` header or `last_event_id` query param (header wins)
+   * and takes precedence over `after`; omit all to tail from the execution start.
    */
   async streamWorkflowExecutionLogs(
     request: operations.StreamWorkflowExecutionLogsRequest,

package/src/sdk/libraries.ts

@@ -87,7 +87,7 @@ export class Libraries extends ClientSDK {
   async delete(
     request: operations.LibrariesDeleteV1Request,
     options?: RequestOptions,
-  ): Promise<components.Library> {
+  ): Promise<components.Library | undefined> {
     return unwrapAsync(betaLibrariesDelete(
       this,
       request,

package/src/sdk/searchindexes.ts

@@ -3,33 +3,204 @@
  * @generated-id: 9a1b36425210
  */
 
-import { betaRagSearchIndexesList } from "../funcs/betaRagSearchIndexesList.js";
+import { betaRagSearchIndexesDocumentLookup } from "../funcs/betaRagSearchIndexesDocumentLookup.js";
+import { betaRagSearchIndexesDocumentsFetch } from "../funcs/betaRagSearchIndexesDocumentsFetch.js";
+import { betaRagSearchIndexesGetIndexDetail } from "../funcs/betaRagSearchIndexesGetIndexDetail.js";
+import { betaRagSearchIndexesGetIndexSchemaDetail } from "../funcs/betaRagSearchIndexesGetIndexSchemaDetail.js";
+import { betaRagSearchIndexesGetIndexSchemaFile } from "../funcs/betaRagSearchIndexesGetIndexSchemaFile.js";
+import { betaRagSearchIndexesGetIndexSummaries } from "../funcs/betaRagSearchIndexesGetIndexSummaries.js";
 import { betaRagSearchIndexesRegister } from "../funcs/betaRagSearchIndexesRegister.js";
+import { betaRagSearchIndexesSetIndexSummary } from "../funcs/betaRagSearchIndexesSetIndexSummary.js";
+import { betaRagSearchIndexesSetSchemaSummary } from "../funcs/betaRagSearchIndexesSetSchemaSummary.js";
+import { betaRagSearchIndexesUnregister } from "../funcs/betaRagSearchIndexesUnregister.js";
+import { betaRagSearchIndexesUpdateIndexMetrics } from "../funcs/betaRagSearchIndexesUpdateIndexMetrics.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
 export class SearchIndexes extends ClientSDK {
   /**
-   * Get Search Indexes
+   * Register (or re-register) a search index
    */
-  async list(
+  async register(
+    request: components.RegisterSearchIndexRequestIndex,
     options?: RequestOptions,
-  ): Promise<Array<components.SearchIndexResponse>> {
-    return unwrapAsync(betaRagSearchIndexesList(
+  ): Promise<components.RegisterSearchIndexResponseIndex> {
+    return unwrapAsync(betaRagSearchIndexesRegister(
       this,
+      request,
       options,
     ));
   }
 
   /**
-   * Register Search Index
+   * Get Index Summaries
+   *
+   * @remarks
+   * Fetch summary view of all indexes available to a user
    */
-  async register(
-    request: components.CreateSearchIndexInfoRequest,
+  async getIndexSummaries(
     options?: RequestOptions,
-  ): Promise<components.SearchIndexResponse> {
-    return unwrapAsync(betaRagSearchIndexesRegister(
+  ): Promise<Array<components.GetSearchIndexSummaryResponseIndex>> {
+    return unwrapAsync(betaRagSearchIndexesGetIndexSummaries(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Unregister Search Index
+   *
+   * @remarks
+   * Delete all information about an index
+   */
+  async unregister(
+    request:
+      operations.UnregisterSearchIndexV1RagIndexesIndexIndexIdDeleteRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(betaRagSearchIndexesUnregister(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update Index Metrics
+   *
+   * @remarks
+   * Update the metrics for a given index
+   */
+  async updateIndexMetrics(
+    request:
+      operations.UpdateIndexMetricsV1RagIndexesIndexIndexIdMetricsPutRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(betaRagSearchIndexesUpdateIndexMetrics(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Index Details
+   *
+   * @remarks
+   * Get a detailed view of the stored data for a single index
+   */
+  async getIndexDetail(
+    request: operations.GetIndexDetailsV1RagIndexesIndexIndexIdDetailGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetSearchIndexDetailResponseIndex> {
+    return unwrapAsync(betaRagSearchIndexesGetIndexDetail(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Set Index Summary
+   *
+   * @remarks
+   * Update the summary field for an index
+   */
+  async setIndexSummary(
+    request:
+      operations.SetIndexSummaryV1RagIndexesIndexIndexIdSummaryFieldPutRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(betaRagSearchIndexesSetIndexSummary(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Index Schema Detail
+   *
+   * @remarks
+   * Get a detailed view of the stored information for a schema
+   */
+  async getIndexSchemaDetail(
+    request:
+      operations.GetIndexSchemaDetailV1RagIndexesIndexIndexIdSchemasSchemaSchemaIdDetailGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetSearchIndexSchemaDetailResponseSchemaModel> {
+    return unwrapAsync(betaRagSearchIndexesGetIndexSchemaDetail(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Set Schema Summary
+   *
+   * @remarks
+   * Update the summary field for an index
+   */
+  async setSchemaSummary(
+    request:
+      operations.SetSchemaSummaryV1RagIndexesIndexIndexIdSchemasSchemaSchemaIdSummaryFieldPutRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(betaRagSearchIndexesSetSchemaSummary(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Index Schema File
+   */
+  async getIndexSchemaFile(
+    request:
+      operations.GetIndexSchemaFileV1RagIndexesIndexIndexIdSchemasSchemaSchemaIdFileGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetSearchIndexSchemaSDFileResponseSDFile> {
+    return unwrapAsync(betaRagSearchIndexesGetIndexSchemaFile(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Document Lookup
+   *
+   * @remarks
+   * Fetch stored information about a retrievable element stored in an index
+   */
+  async documentLookup(
+    request:
+      operations.DocumentLookupV1RagIndexesIndexIndexIdSchemasSchemaSchemaIdRetrievablesRetrievableDocumentIdGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.VespaGetRetrievableResponseRetrievable> {
+    return unwrapAsync(betaRagSearchIndexesDocumentLookup(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Document Fetch
+   *
+   * @remarks
+   * Fetch a few stored retrievable elements from the index/schema
+   */
+  async documentsFetch(
+    request:
+      operations.DocumentFetchV1RagIndexesIndexIndexIdSchemasSchemaSchemaIdRetrievablesGetRequest,
+    options?: RequestOptions,
+  ): Promise<Array<components.VespaGetRetrievableResponseRetrievable>> {
+    return unwrapAsync(betaRagSearchIndexesDocumentsFetch(
       this,
       request,
       options,

package/tests/extra/observability/customProvider.test.ts

@@ -4,6 +4,7 @@ import {
   getOrCreateOtelTracer,
   registerTracerProvider,
 } from "../../../src/extra/observability/otel.js";
+import { MISTRAL_SDK_TELEMETRY_ENV } from "../../../src/extra/observability/telemetry.js";
 import {
   TracingHook,
   type TracingContext,
@@ -37,8 +38,19 @@ function createHookContext(): TracingContext {
   } as TracingContext;
 }
 
+const ORIGINAL_MISTRAL_SDK_TELEMETRY = process.env[MISTRAL_SDK_TELEMETRY_ENV];
+
+beforeEach(() => {
+  delete process.env[MISTRAL_SDK_TELEMETRY_ENV];
+});
+
 afterEach(() => {
   registerTracerProvider();
+  if (ORIGINAL_MISTRAL_SDK_TELEMETRY === undefined) {
+    delete process.env[MISTRAL_SDK_TELEMETRY_ENV];
+  } else {
+    process.env[MISTRAL_SDK_TELEMETRY_ENV] = ORIGINAL_MISTRAL_SDK_TELEMETRY;
+  }
 });
 
 describe("getOrCreateOtelTracer", () => {
@@ -66,6 +78,21 @@ describe("getOrCreateOtelTracer", () => {
     expect((tracer as any).label).toBe("registered");
     spy.mockRestore();
   });
+
+  test("can bypass registered provider for explicit global mode", () => {
+    const registeredTracer = createMockTracer("registered");
+    const globalTracer = createMockTracer("global");
+    registerTracerProvider(createMockTracerProvider(registeredTracer));
+    const spy = vi
+      .spyOn(trace, "getTracerProvider")
+      .mockReturnValue(createMockTracerProvider(globalTracer));
+
+    const tracer = getOrCreateOtelTracer(undefined, { useRegisteredProvider: false });
+
+    expect(spy).toHaveBeenCalled();
+    expect((tracer as any).label).toBe("global");
+    spy.mockRestore();
+  });
 });
 
 describe("TracingHook with registered TracerProvider", () => {
@@ -81,13 +108,14 @@ describe("TracingHook with registered TracerProvider", () => {
     expect((ctx[TRACING_TRACER_KEY] as any).label).toBe("registered");
   });
 
-  test("beforeRequest falls back to global provider when no provider is registered", async () => {
+  test("beforeRequest uses global provider when env telemetry opts in", async () => {
     const hook = new TracingHook();
     const globalTracer = createMockTracer("global");
     const spy = vi
       .spyOn(trace, "getTracerProvider")
       .mockReturnValue(createMockTracerProvider(globalTracer));
 
+    process.env[MISTRAL_SDK_TELEMETRY_ENV] = "global";
     const ctx = createHookContext();
     await hook.beforeRequest(ctx, createChatRequest());
 
@@ -95,4 +123,37 @@ describe("TracingHook with registered TracerProvider", () => {
     expect((ctx[TRACING_TRACER_KEY] as any).label).toBe("global");
     spy.mockRestore();
   });
+
+  test("beforeRequest global telemetry bypasses registered provider", async () => {
+    const hook = new TracingHook();
+    const registeredTracer = createMockTracer("registered");
+    const globalTracer = createMockTracer("global");
+    registerTracerProvider(createMockTracerProvider(registeredTracer));
+    const spy = vi
+      .spyOn(trace, "getTracerProvider")
+      .mockReturnValue(createMockTracerProvider(globalTracer));
+
+    process.env[MISTRAL_SDK_TELEMETRY_ENV] = "global";
+    const ctx = createHookContext();
+    await hook.beforeRequest(ctx, createChatRequest());
+
+    expect(spy).toHaveBeenCalled();
+    expect((ctx[TRACING_TRACER_KEY] as any).label).toBe("global");
+    spy.mockRestore();
+  });
+
+  test("beforeRequest does not use global provider without Mistral telemetry", async () => {
+    const hook = new TracingHook();
+    const globalTracer = createMockTracer("global");
+    const spy = vi
+      .spyOn(trace, "getTracerProvider")
+      .mockReturnValue(createMockTracerProvider(globalTracer));
+
+    const ctx = createHookContext();
+    await hook.beforeRequest(ctx, createChatRequest());
+
+    expect(spy).not.toHaveBeenCalled();
+    expect(ctx[TRACING_TRACER_KEY]).toBeUndefined();
+    spy.mockRestore();
+  });
 });

package/tests/extra/observability/streaming.test.ts

@@ -88,6 +88,30 @@ describe("accumulateChunksToResponseDict", () => {
     ]);
   });
 
+  test("accumulates content when delta.content is an array of ContentChunk objects", () => {
+    const arrayContentChunk: Record<string, unknown> = {
+      id: "id-1",
+      model: "m",
+      choices: [{
+        index: 0,
+        delta: {
+          role: "assistant",
+          content: [{ type: "text", text: "Bonjour" }],
+        },
+        finish_reason: null,
+      }],
+    };
+    const chunks = parseSseChunks(toSse([
+      arrayContentChunk,
+      chunk({ content: " monde", finishReason: "stop" }),
+    ]));
+    const result = accumulateChunksToResponseDict(chunks);
+    expect(result.choices).toEqual([{
+      message: { role: "assistant", content: "Bonjour monde" },
+      finish_reason: "stop",
+    }]);
+  });
+
   test("handles empty chunks", () => {
     expect(accumulateChunksToResponseDict([])).toEqual({ id: undefined, model: undefined, choices: [] });
   });