@mistralai/mistralai 1.13.0 → 1.14.1

package/src/extra/realtime/transcription.ts

@@ -0,0 +1,291 @@
+import WebSocket from "ws";
+import { SDK_METADATA } from "../../lib/config.js";
+import { ClientSDK } from "../../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import type { AudioFormat } from "../../models/components/audioformat.js";
+import type {
+  RealtimeTranscriptionError,
+} from "../../models/components/realtimetranscriptionerror.js";
+import type { RealtimeTranscriptionSession } from "../../models/components/realtimetranscriptionsession.js";
+import type { RealtimeEvent } from "./connection.js";
+import {
+  RealtimeConnection,
+  isUnknownRealtimeEvent,
+  parseRealtimeEventFromData,
+} from "./connection.js";
+import {
+  RealtimeTranscriptionException,
+  RealtimeTranscriptionWSError,
+} from "./errors.js";
+
+export type RealtimeConnectOptions = Readonly<{
+  audioFormat?: AudioFormat | undefined;
+  serverUrl?: string | undefined;
+  timeoutMs?: number | undefined;
+  httpHeaders?: Record<string, string> | undefined;
+}>;
+
+/** Client for realtime transcription over WebSocket. */
+export class RealtimeTranscription extends ClientSDK {
+  async connect(
+    model: string,
+    options: RealtimeConnectOptions = {},
+  ): Promise<RealtimeConnection> {
+    const securityInput = await extractSecurity(this._options.apiKey);
+    const resolvedSecurity = resolveGlobalSecurity(
+      securityInput == null ? {} : { apiKey: securityInput },
+    );
+
+    const headers: Record<string, string> = {};
+
+    headers["User-Agent"] = this._options.userAgent ?? SDK_METADATA.userAgent;
+
+    if (resolvedSecurity?.headers) {
+      Object.assign(headers, resolvedSecurity.headers);
+    }
+
+    if (options.httpHeaders) {
+      Object.assign(headers, options.httpHeaders);
+    }
+
+    const url = this.getWsUrl(model, {
+      serverUrl: options.serverUrl,
+      queryParams: resolvedSecurity?.queryParams ?? {},
+    });
+
+    let websocket: WebSocket | undefined;
+    try {
+      websocket = new WebSocket(url, { headers });
+      const { session, initialEvents } = await recvSession(
+        websocket,
+        options.timeoutMs ?? this._options.timeoutMs,
+      );
+      const connection = new RealtimeConnection(websocket, session, initialEvents);
+
+      if (options.audioFormat) {
+        await connection.updateSession(options.audioFormat);
+      }
+
+      return connection;
+    } catch (err) {
+      if (err instanceof RealtimeTranscriptionException) {
+        throw err;
+      }
+
+      if (websocket) {
+        websocket.close();
+      }
+
+      throw new RealtimeTranscriptionException(
+        `Failed to connect to transcription service: ${String(err)}`,
+        { cause: err },
+      );
+    }
+  }
+
+  async *transcribeStream(
+    audioStream: AsyncIterable<Uint8Array>,
+    model: string,
+    options: RealtimeConnectOptions = {},
+  ): AsyncIterable<RealtimeEvent> {
+    const connection = await this.connect(model, options);
+
+    let stopRequested = false;
+    const sendAudioTask = (async () => {
+      try {
+        for await (const chunk of audioStream) {
+          if (stopRequested || connection.isClosed) {
+            break;
+          }
+          await connection.sendAudio(chunk);
+        }
+      } finally {
+        if (!connection.isClosed) {
+          await connection.flushAudio();
+        }
+        await connection.endAudio();
+      }
+    })();
+
+    try {
+      for await (const event of connection) {
+        yield event;
+
+        if (event.type === "transcription.done") {
+          break;
+        }
+
+        if (event.type === "error") {
+          break;
+        }
+      }
+    } finally {
+      stopRequested = true;
+
+      await connection.close();
+      await sendAudioTask;
+      const maybeReturn =
+        (audioStream as { return?: () => Promise<IteratorResult<Uint8Array>> }).return;
+      if (typeof maybeReturn === "function") {
+        await maybeReturn.call(audioStream);
+      }
+    }
+  }
+
+  private getWsUrl(
+    model: string,
+    options: { serverUrl?: string | undefined; queryParams: Record<string, string> },
+  ): string {
+    const baseUrl = options.serverUrl ?? this._baseURL?.toString();
+    if (!baseUrl) {
+      throw new RealtimeTranscriptionException("No server URL configured.");
+    }
+
+    const wsUrl = new URL(
+      "v1/audio/transcriptions/realtime",
+      normalizeBaseUrl(baseUrl),
+    );
+
+    const params = new URLSearchParams({ model });
+    for (const [key, value] of Object.entries(options.queryParams)) {
+      if (value) {
+        params.set(key, value);
+      }
+    }
+    wsUrl.search = params.toString();
+
+    return wsUrl.toString();
+  }
+}
+
+async function recvSession(
+  websocket: WebSocket,
+  timeoutMs?: number,
+): Promise<{ session: RealtimeTranscriptionSession; initialEvents: RealtimeEvent[] }> {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  const initialEvents: RealtimeEvent[] = [];
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      websocket.removeEventListener("message", handleMessage);
+      websocket.removeEventListener("close", handleClose);
+      websocket.removeEventListener("error", handleError);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+
+    const fail = (error: Error) => {
+      cleanup();
+      try {
+        websocket.close();
+      } catch (closeError) {
+        void closeError;
+      }
+      reject(error);
+    };
+
+    const handleMessage = (event: WebSocket.MessageEvent) => {
+      const parsed = parseRealtimeEventFromData(event.data);
+      initialEvents.push(parsed);
+
+      if (parsed.type === "error") {
+        if (isUnknownRealtimeEvent(parsed)) {
+          fail(new RealtimeTranscriptionWSError(
+            parsed.error?.message ?? "Realtime transcription error during handshake.",
+            {
+              rawPayload: parsed.raw,
+              cause: parsed.error,
+            },
+          ));
+          return;
+        }
+
+        if (isRealtimeErrorEvent(parsed)) {
+          const errorMessage = typeof parsed.error.message === "string"
+            ? parsed.error.message
+            : JSON.stringify(parsed.error.message);
+          fail(new RealtimeTranscriptionWSError(
+            errorMessage,
+            {
+              payload: parsed,
+              code: parsed.error.code,
+            },
+          ));
+          return;
+        }
+      }
+
+      if (isUnknownRealtimeEvent(parsed)) {
+        return;
+      }
+
+      if (isSessionCreatedEvent(parsed)) {
+        cleanup();
+        resolve({ session: parsed.session, initialEvents });
+      }
+    };
+
+    const handleClose = () => {
+      fail(new RealtimeTranscriptionException(
+        "Unexpected websocket handshake close.",
+      ));
+    };
+
+    const handleError = (event: unknown) => {
+      fail(new RealtimeTranscriptionException(
+        "Failed to connect to transcription service.",
+        { cause: normalizeWsError(event) },
+      ));
+    };
+
+    websocket.addEventListener("message", handleMessage);
+    websocket.addEventListener("close", handleClose);
+    websocket.addEventListener("error", handleError);
+
+    if (timeoutMs && timeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        fail(new RealtimeTranscriptionException(
+          "Timeout waiting for session creation.",
+        ));
+      }, timeoutMs);
+    }
+  });
+}
+
+function normalizeWsError(event: unknown): Error {
+  if (event instanceof Error) {
+    return event;
+  }
+
+  if (
+    typeof event === "object"
+    && event !== null
+    && "error" in event
+    && (event as { error?: unknown }).error instanceof Error
+  ) {
+    return (event as { error: Error }).error;
+  }
+
+  return new Error("WebSocket connection error");
+}
+
+function isRealtimeErrorEvent(
+  event: RealtimeEvent,
+): event is RealtimeTranscriptionError {
+  return !isUnknownRealtimeEvent(event) && "error" in event;
+}
+
+function isSessionCreatedEvent(
+  event: RealtimeEvent,
+): event is { type: "session.created"; session: RealtimeTranscriptionSession } {
+  return !isUnknownRealtimeEvent(event)
+    && "session" in event
+    && event.type === "session.created";
+}
+
+function normalizeBaseUrl(baseUrl: string): URL {
+  const url = new URL(baseUrl);
+  url.pathname = url.pathname.replace(/\/+$/, "") + "/";
+  return url;
+}

package/src/extra/structChat.ts

@@ -66,7 +66,7 @@ export function convertToParsedChatCompletionResponse<T extends z.ZodTypeAny>(re
 
   // Function to convert Zod schema to strict JSON schema
 export function responseFormatFromZodObject<T extends z.ZodTypeAny>(responseFormat: T): ResponseFormat {
-  const responseJsonSchema = zodToJsonSchema(responseFormat);
+  const responseJsonSchema = zodToJsonSchema(responseFormat as z.ZodType<any, z.ZodTypeDef, any>);
   // It is not possible to get the variable name of a Zod object at runtime in TypeScript so we're using a placeholder name.
   // This has not impact on the parsing as the initial Zod object is used to parse the response.
   const placeholderName = "placeholderName"
@@ -78,4 +78,4 @@ export function responseFormatFromZodObject<T extends z.ZodTypeAny>(responseForm
       strict: true,
     },
   };
-}
+}

package/src/funcs/audioTranscriptionsComplete.ts

@@ -89,6 +89,12 @@ async function $do(
   const body = new FormData();
 
   appendForm(body, "model", payload.model);
+  if (payload.context_bias !== undefined) {
+    appendForm(body, "context_bias", payload.context_bias);
+  }
+  if (payload.diarize !== undefined) {
+    appendForm(body, "diarize", payload.diarize);
+  }
   if (payload.file !== undefined) {
     if (isBlobLike(payload.file)) {
       appendForm(body, "file", payload.file);

package/src/funcs/audioTranscriptionsStream.ts

@@ -92,6 +92,12 @@ async function $do(
   const body = new FormData();
 
   appendForm(body, "model", payload.model);
+  if (payload.context_bias !== undefined) {
+    appendForm(body, "context_bias", payload.context_bias);
+  }
+  if (payload.diarize !== undefined) {
+    appendForm(body, "diarize", payload.diarize);
+  }
   if (payload.file !== undefined) {
     if (isBlobLike(payload.file)) {
       appendForm(body, "file", payload.file);

package/src/funcs/batchJobsList.ts

@@ -96,6 +96,7 @@ async function $do(
     "created_by_me": payload?.created_by_me,
     "metadata": payload?.metadata,
     "model": payload?.model,
+    "order_by": payload?.order_by,
     "page": payload?.page,
     "page_size": payload?.page_size,
     "status": payload?.status,

package/src/funcs/betaAgentsCreateVersionAlias.ts

@@ -0,0 +1,184 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { MistralCore } from "../core.js";
+import { encodeFormQuery, encodeSimple } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as components from "../models/components/index.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { MistralError } from "../models/errors/mistralerror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Create or update an agent version alias.
+ *
+ * @remarks
+ * Create a new alias or update an existing alias to point to a specific version. Aliases are unique per agent and can be reassigned to different versions.
+ */
+export function betaAgentsCreateVersionAlias(
+  client: MistralCore,
+  request: operations.AgentsApiV1AgentsCreateOrUpdateAliasRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    components.AgentAliasResponse,
+    | errors.HTTPValidationError
+    | MistralError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: MistralCore,
+  request: operations.AgentsApiV1AgentsCreateOrUpdateAliasRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      components.AgentAliasResponse,
+      | errors.HTTPValidationError
+      | MistralError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) =>
+      operations.AgentsApiV1AgentsCreateOrUpdateAliasRequest$outboundSchema
+        .parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const pathParams = {
+    agent_id: encodeSimple("agent_id", payload.agent_id, {
+      explode: false,
+      charEncoding: "percent",
+    }),
+  };
+
+  const path = pathToFunc("/v1/agents/{agent_id}/aliases")(pathParams);
+
+  const query = encodeFormQuery({
+    "alias": payload.alias,
+    "version": payload.version,
+  });
+
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "agents_api_v1_agents_create_or_update_alias",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PUT",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    query: query,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    components.AgentAliasResponse,
+    | errors.HTTPValidationError
+    | MistralError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, components.AgentAliasResponse$inboundSchema),
+    M.jsonErr(422, errors.HTTPValidationError$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/funcs/betaAgentsDeleteVersionAlias.ts

@@ -0,0 +1,184 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { MistralCore } from "../core.js";
+import { encodeFormQuery, encodeSimple } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { MistralError } from "../models/errors/mistralerror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Delete an agent version alias.
+ *
+ * @remarks
+ * Delete an existing alias for an agent.
+ */
+export function betaAgentsDeleteVersionAlias(
+  client: MistralCore,
+  request: operations.AgentsApiV1AgentsDeleteAliasRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    void,
+    | errors.HTTPValidationError
+    | MistralError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: MistralCore,
+  request: operations.AgentsApiV1AgentsDeleteAliasRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      void,
+      | errors.HTTPValidationError
+      | MistralError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) =>
+      operations.AgentsApiV1AgentsDeleteAliasRequest$outboundSchema.parse(
+        value,
+      ),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const pathParams = {
+    agent_id: encodeSimple("agent_id", payload.agent_id, {
+      explode: false,
+      charEncoding: "percent",
+    }),
+  };
+
+  const path = pathToFunc("/v1/agents/{agent_id}/aliases")(pathParams);
+
+  const query = encodeFormQuery({
+    "alias": payload.alias,
+  });
+
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "agents_api_v1_agents_delete_alias",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "DELETE",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    query: query,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    void,
+    | errors.HTTPValidationError
+    | MistralError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.nil(204, z.void()),
+    M.jsonErr(422, errors.HTTPValidationError$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}