@mistralai/mistralai 1.13.0 → 1.14.1

package/src/models/operations/agentsapiv1agentslistversionaliases.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type AgentsApiV1AgentsListVersionAliasesRequest = {
+  agentId: string;
+};
+
+/** @internal */
+export type AgentsApiV1AgentsListVersionAliasesRequest$Outbound = {
+  agent_id: string;
+};
+
+/** @internal */
+export const AgentsApiV1AgentsListVersionAliasesRequest$outboundSchema:
+  z.ZodType<
+    AgentsApiV1AgentsListVersionAliasesRequest$Outbound,
+    z.ZodTypeDef,
+    AgentsApiV1AgentsListVersionAliasesRequest
+  > = z.object({
+    agentId: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      agentId: "agent_id",
+    });
+  });
+
+export function agentsApiV1AgentsListVersionAliasesRequestToJSON(
+  agentsApiV1AgentsListVersionAliasesRequest:
+    AgentsApiV1AgentsListVersionAliasesRequest,
+): string {
+  return JSON.stringify(
+    AgentsApiV1AgentsListVersionAliasesRequest$outboundSchema.parse(
+      agentsApiV1AgentsListVersionAliasesRequest,
+    ),
+  );
+}

package/src/models/operations/filesapirouteslistfiles.ts

@@ -14,6 +14,7 @@ export type FilesApiRoutesListFilesRequest = {
   source?: Array<components.Source> | null | undefined;
   search?: string | null | undefined;
   purpose?: components.FilePurpose | null | undefined;
+  mimetypes?: Array<string> | null | undefined;
 };
 
 /** @internal */
@@ -25,6 +26,7 @@ export type FilesApiRoutesListFilesRequest$Outbound = {
   source?: Array<string> | null | undefined;
   search?: string | null | undefined;
   purpose?: string | null | undefined;
+  mimetypes?: Array<string> | null | undefined;
 };
 
 /** @internal */
@@ -41,6 +43,7 @@ export const FilesApiRoutesListFilesRequest$outboundSchema: z.ZodType<
   source: z.nullable(z.array(components.Source$outboundSchema)).optional(),
   search: z.nullable(z.string()).optional(),
   purpose: z.nullable(components.FilePurpose$outboundSchema).optional(),
+  mimetypes: z.nullable(z.array(z.string())).optional(),
 }).transform((v) => {
   return remap$(v, {
     pageSize: "page_size",

package/src/models/operations/index.ts

@@ -2,10 +2,13 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+export * from "./agentsapiv1agentscreateorupdatealias.js";
 export * from "./agentsapiv1agentsdelete.js";
+export * from "./agentsapiv1agentsdeletealias.js";
 export * from "./agentsapiv1agentsget.js";
 export * from "./agentsapiv1agentsgetversion.js";
 export * from "./agentsapiv1agentslist.js";
+export * from "./agentsapiv1agentslistversionaliases.js";
 export * from "./agentsapiv1agentslistversions.js";
 export * from "./agentsapiv1agentsupdate.js";
 export * from "./agentsapiv1agentsupdateversion.js";

package/src/models/operations/jobsapiroutesbatchgetbatchjobs.ts

@@ -4,8 +4,15 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
 import * as components from "../components/index.js";
 
+export const OrderBy = {
+  Created: "created",
+  MinusCreated: "-created",
+} as const;
+export type OrderBy = ClosedEnum<typeof OrderBy>;
+
 export type JobsApiRoutesBatchGetBatchJobsRequest = {
   page?: number | undefined;
   pageSize?: number | undefined;
@@ -15,8 +22,13 @@ export type JobsApiRoutesBatchGetBatchJobsRequest = {
   createdAfter?: Date | null | undefined;
   createdByMe?: boolean | undefined;
   status?: Array<components.BatchJobStatus> | null | undefined;
+  orderBy?: OrderBy | undefined;
 };
 
+/** @internal */
+export const OrderBy$outboundSchema: z.ZodNativeEnum<typeof OrderBy> = z
+  .nativeEnum(OrderBy);
+
 /** @internal */
 export type JobsApiRoutesBatchGetBatchJobsRequest$Outbound = {
   page: number;
@@ -27,6 +39,7 @@ export type JobsApiRoutesBatchGetBatchJobsRequest$Outbound = {
   created_after?: string | null | undefined;
   created_by_me: boolean;
   status?: Array<string> | null | undefined;
+  order_by: string;
 };
 
 /** @internal */
@@ -44,12 +57,14 @@ export const JobsApiRoutesBatchGetBatchJobsRequest$outboundSchema: z.ZodType<
   createdByMe: z.boolean().default(false),
   status: z.nullable(z.array(components.BatchJobStatus$outboundSchema))
     .optional(),
+  orderBy: OrderBy$outboundSchema.default("-created"),
 }).transform((v) => {
   return remap$(v, {
     pageSize: "page_size",
     agentId: "agent_id",
     createdAfter: "created_after",
     createdByMe: "created_by_me",
+    orderBy: "order_by",
   });
 });
 

package/src/sdk/mistralagents.ts

@@ -3,10 +3,13 @@
  */
 
 import { betaAgentsCreate } from "../funcs/betaAgentsCreate.js";
+import { betaAgentsCreateVersionAlias } from "../funcs/betaAgentsCreateVersionAlias.js";
 import { betaAgentsDelete } from "../funcs/betaAgentsDelete.js";
+import { betaAgentsDeleteVersionAlias } from "../funcs/betaAgentsDeleteVersionAlias.js";
 import { betaAgentsGet } from "../funcs/betaAgentsGet.js";
 import { betaAgentsGetVersion } from "../funcs/betaAgentsGetVersion.js";
 import { betaAgentsList } from "../funcs/betaAgentsList.js";
+import { betaAgentsListVersionAliases } from "../funcs/betaAgentsListVersionAliases.js";
 import { betaAgentsListVersions } from "../funcs/betaAgentsListVersions.js";
 import { betaAgentsUpdate } from "../funcs/betaAgentsUpdate.js";
 import { betaAgentsUpdateVersion } from "../funcs/betaAgentsUpdateVersion.js";
@@ -54,7 +57,7 @@ export class MistralAgents extends ClientSDK {
    * Retrieve an agent entity.
    *
    * @remarks
-   * Given an agent retrieve an agent entity with its attributes.
+   * Given an agent, retrieve an agent entity with its attributes. The agent_version parameter can be an integer version number or a string alias.
    */
   async get(
     request: operations.AgentsApiV1AgentsGetRequest,
@@ -148,4 +151,55 @@ export class MistralAgents extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * 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.
+   */
+  async createVersionAlias(
+    request: operations.AgentsApiV1AgentsCreateOrUpdateAliasRequest,
+    options?: RequestOptions,
+  ): Promise<components.AgentAliasResponse> {
+    return unwrapAsync(betaAgentsCreateVersionAlias(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List all aliases for an agent.
+   *
+   * @remarks
+   * Retrieve all version aliases for a specific agent.
+   */
+  async listVersionAliases(
+    request: operations.AgentsApiV1AgentsListVersionAliasesRequest,
+    options?: RequestOptions,
+  ): Promise<Array<components.AgentAliasResponse>> {
+    return unwrapAsync(betaAgentsListVersionAliases(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete an agent version alias.
+   *
+   * @remarks
+   * Delete an existing alias for an agent.
+   */
+  async deleteVersionAlias(
+    request: operations.AgentsApiV1AgentsDeleteAliasRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(betaAgentsDeleteVersionAlias(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/tests/extra/realtime.test.ts

@@ -0,0 +1,389 @@
+import type WebSocket from "ws";
+import type { RealtimeTranscriptionSession } from "../../extra/realtime";
+import { RealtimeTranscriptionWSError } from "../../extra/realtime/errors";
+
+jest.mock("ws", () => {
+  class MockWebSocket {
+    readyState = 1;
+    sent: string[] = [];
+    closeArgs: { code?: number; reason?: string } | null = null;
+    private listeners = new Map<string, Set<(event: any) => void>>();
+
+    addEventListener(event: string, handler: (event: any) => void): void {
+      if (!this.listeners.has(event)) {
+        this.listeners.set(event, new Set());
+      }
+      this.listeners.get(event)?.add(handler);
+    }
+
+    removeEventListener(event: string, handler: (event: any) => void): void {
+      this.listeners.get(event)?.delete(handler);
+    }
+
+    send(data: string, cb?: (err?: Error) => void): void {
+      this.sent.push(data);
+      cb?.();
+    }
+
+    close(code?: number, reason?: string): void {
+      this.closeArgs = { code, reason };
+      this.readyState = 3;
+      this.emit("close", { code, reason });
+    }
+
+    emit(event: string, data: any): void {
+      for (const handler of this.listeners.get(event) ?? []) {
+        handler(data);
+      }
+    }
+
+    emitMessage(payload: unknown): void {
+      const data = typeof payload === "string" ? payload : JSON.stringify(payload);
+      this.emit("message", { data });
+    }
+  }
+
+  let lastSocket: MockWebSocket | undefined;
+
+  const WebSocket = jest.fn(() => {
+    lastSocket = new MockWebSocket();
+    return lastSocket;
+  });
+
+  return {
+    __esModule: true,
+    default: WebSocket,
+    MockWebSocket,
+    getLastSocket: () => lastSocket,
+  };
+});
+
+type MockWebSocketInstance = {
+  readyState: number;
+  sent: string[];
+  closeArgs: { code?: number; reason?: string } | null;
+  addEventListener(event: string, handler: (event: any) => void): void;
+  removeEventListener(event: string, handler: (event: any) => void): void;
+  send(data: string, cb?: (err?: Error) => void): void;
+  close(code?: number, reason?: string): void;
+  emit(event: string, data: any): void;
+  emitMessage(payload: unknown): void;
+};
+
+let AudioEncoding: typeof import("../../extra/realtime").AudioEncoding;
+let RealtimeConnection: typeof import("../../extra/realtime").RealtimeConnection;
+let RealtimeTranscription: typeof import("../../extra/realtime").RealtimeTranscription;
+
+beforeAll(async () => {
+  const realtime = await import("../../extra/realtime");
+  AudioEncoding = realtime.AudioEncoding;
+  RealtimeConnection = realtime.RealtimeConnection;
+  RealtimeTranscription = realtime.RealtimeTranscription;
+});
+
+function getMockModule(): {
+  MockWebSocket: new () => MockWebSocketInstance;
+  getLastSocket: () => MockWebSocketInstance | undefined;
+} {
+  return jest.requireMock("ws") as unknown as {
+    MockWebSocket: new () => MockWebSocketInstance;
+    getLastSocket: () => MockWebSocketInstance | undefined;
+  };
+}
+
+async function waitForSocket(
+  previous?: MockWebSocketInstance,
+): Promise<MockWebSocketInstance> {
+  const { getLastSocket } = getMockModule();
+  for (let i = 0; i < 10; i += 1) {
+    const ws = getLastSocket();
+    if (ws && ws !== previous) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      return ws;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  throw new Error("WebSocket was not created");
+}
+
+function makeSession(): RealtimeTranscriptionSession {
+  return {
+    requestId: "ws-123456",
+    model: "voxtral-realtime",
+    audioFormat: {
+      encoding: AudioEncoding.PcmS16le,
+      sampleRate: 16000,
+    },
+  };
+}
+
+function makeSessionCreatedMessage() {
+  return {
+    type: "session.created",
+    session: {
+      request_id: "ws-123456",
+      model: "voxtral-realtime",
+      audio_format: {
+        encoding: "pcm_s16le",
+        sample_rate: 16000,
+      },
+    },
+  };
+}
+
+async function collectNext(
+  iterator: AsyncIterator<any>,
+  ws: MockWebSocketInstance,
+  payload: unknown,
+) {
+  const nextPromise = iterator.next();
+  ws.emitMessage(payload);
+  return await nextPromise;
+}
+
+describe("RealtimeConnection async iterator", () => {
+  it("yields UnknownRealtimeEvent for unknown types", async () => {
+    const { MockWebSocket } = getMockModule();
+    const ws = new MockWebSocket();
+    const connection = new RealtimeConnection(
+      ws as unknown as WebSocket,
+      makeSession(),
+    );
+
+    const iterator = connection[Symbol.asyncIterator]();
+    const result = await collectNext(iterator, ws, {
+      type: "transcription.surprise",
+      payload: "hello",
+    });
+
+    expect(result.done).toBe(false);
+    expect(result.value.type).toBe("transcription.surprise");
+    expect(result.value.raw).toEqual({
+      type: "transcription.surprise",
+      payload: "hello",
+    });
+
+    const donePromise = iterator.next();
+    ws.close();
+    await donePromise;
+  });
+
+  it("yields UnknownRealtimeEvent on schema parse failure", async () => {
+    const { MockWebSocket } = getMockModule();
+    const ws = new MockWebSocket();
+    const connection = new RealtimeConnection(
+      ws as unknown as WebSocket,
+      makeSession(),
+    );
+
+    const iterator = connection[Symbol.asyncIterator]();
+    const result = await collectNext(iterator, ws, {
+      type: "transcription.text.delta",
+    });
+
+    expect(result.done).toBe(false);
+    expect(result.value.type).toBe("transcription.text.delta");
+    expect(result.value.error).toBeInstanceOf(Error);
+
+    const donePromise = iterator.next();
+    ws.close();
+    await donePromise;
+  });
+});
+
+describe("RealtimeTranscription handshake", () => {
+  it("replays pre-session events", async () => {
+    const { getLastSocket } = getMockModule();
+    const client = new RealtimeTranscription({
+      apiKey: "test",
+      serverURL: "wss://example.com",
+    });
+
+    const previousSocket = getMockModule().getLastSocket();
+    const connectPromise = client.connect("voxtral-realtime");
+    const ws = await waitForSocket(previousSocket);
+
+    ws.emitMessage({
+      type: "transcription.text.delta",
+      text: "hello",
+    });
+    ws.emitMessage(makeSessionCreatedMessage());
+
+    const connection = await connectPromise;
+    const iterator = connection[Symbol.asyncIterator]();
+
+    const first = await iterator.next();
+    expect(first.value.type).toBe("transcription.text.delta");
+
+    const second = await iterator.next();
+    expect(second.value.type).toBe("session.created");
+
+    const donePromise = iterator.next();
+    ws.close();
+    await donePromise;
+  });
+
+  it("throws RealtimeTranscriptionWSError on server error", async () => {
+    const { getLastSocket } = getMockModule();
+    const client = new RealtimeTranscription({
+      apiKey: "test",
+      serverURL: "wss://example.com",
+    });
+
+    const previousSocket = getMockModule().getLastSocket();
+    const connectPromise = client.connect("voxtral-realtime");
+    const ws = await waitForSocket(previousSocket);
+
+    ws.emitMessage({
+      type: "error",
+      error: {
+        message: "bad request",
+        code: 400,
+      },
+    });
+
+    const error = await connectPromise.then(
+      () => new Error("Expected connection to fail"),
+      (err) => err as Error,
+    );
+    expect(error).toBeInstanceOf(RealtimeTranscriptionWSError);
+    expect(error).toMatchObject({
+      payload: {
+        type: "error",
+        error: {
+          message: "bad request",
+          code: 400,
+        },
+      },
+      code: 400,
+    });
+  });
+
+  it("preserves raw payload when error schema fails", async () => {
+    const { getLastSocket } = getMockModule();
+    const client = new RealtimeTranscription({
+      apiKey: "test",
+      serverURL: "wss://example.com",
+    });
+
+    const previousSocket = getMockModule().getLastSocket();
+    const connectPromise = client.connect("voxtral-realtime");
+    const ws = await waitForSocket(previousSocket);
+
+    const rawPayload = {
+      type: "error",
+      error: {
+        message: "missing code",
+      },
+    };
+    ws.emitMessage(rawPayload);
+
+    const error = await connectPromise.then(
+      () => new Error("Expected connection to fail"),
+      (err) => err as Error,
+    );
+    expect(error).toBeInstanceOf(RealtimeTranscriptionWSError);
+    expect(error).toMatchObject({ rawPayload });
+  });
+});
+
+describe("RealtimeTranscription.transcribeStream", () => {
+  it("stops on transcription.done and closes websocket", async () => {
+    const { getLastSocket } = getMockModule();
+    const client = new RealtimeTranscription({
+      apiKey: "test",
+      serverURL: "wss://example.com",
+    });
+
+    async function* audioStream() {
+      yield new Uint8Array([0, 1, 2, 3]);
+      yield new Uint8Array([4, 5, 6, 7]);
+    }
+
+    const previousSocket = getMockModule().getLastSocket();
+    const eventsPromise = (async () => {
+      const events = [] as Array<{ type: string }>;
+      for await (const event of client.transcribeStream(
+        audioStream(),
+        "voxtral-realtime",
+        {
+          audioFormat: {
+            encoding: AudioEncoding.PcmS16le,
+            sampleRate: 16000,
+          },
+        },
+      )) {
+        events.push(event as { type: string });
+      }
+      return events;
+    })();
+
+    const ws = await waitForSocket(previousSocket);
+
+    ws.emitMessage(makeSessionCreatedMessage());
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    ws.emitMessage({
+      type: "transcription.text.delta",
+      text: "hello",
+    });
+    ws.emitMessage({
+      type: "transcription.done",
+      model: "voxtral-realtime",
+      text: "hello",
+      usage: { input_tokens: 0, output_tokens: 0 },
+      language: null,
+    });
+
+    const events = await eventsPromise;
+    expect(events.map((event) => event.type)).toContain("transcription.done");
+    const sentMessageTypes = ws.sent.map((message) => {
+      const parsed = JSON.parse(message) as { type?: string };
+      return parsed.type;
+    });
+    const flushIndex = sentMessageTypes.lastIndexOf("input_audio.flush");
+    const endIndex = sentMessageTypes.lastIndexOf("input_audio.end");
+    expect(flushIndex).toBeGreaterThan(-1);
+    expect(endIndex).toBeGreaterThan(flushIndex);
+    expect(ws.closeArgs?.code).toBe(1000);
+  });
+
+  it("stops on server error and closes websocket", async () => {
+    const { getLastSocket } = getMockModule();
+    const client = new RealtimeTranscription({
+      apiKey: "test",
+      serverURL: "wss://example.com",
+    });
+
+    async function* audioStream() {
+      yield new Uint8Array([1, 2, 3]);
+    }
+
+    const previousSocket = getMockModule().getLastSocket();
+    const eventsPromise = (async () => {
+      const events = [] as Array<{ type: string }>;
+      for await (const event of client.transcribeStream(
+        audioStream(),
+        "voxtral-realtime",
+      )) {
+        events.push(event as { type: string });
+      }
+      return events;
+    })();
+
+    const ws = await waitForSocket(previousSocket);
+
+    ws.emitMessage(makeSessionCreatedMessage());
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    ws.emitMessage({
+      type: "error",
+      error: {
+        message: "bad request",
+        code: 400,
+      },
+    });
+
+    const events = await eventsPromise;
+    expect(events.map((event) => event.type)).toContain("error");
+    expect(ws.closeArgs?.code).toBe(1000);
+  });
+});