@mistralai/mistralai 1.15.1 → 2.0.0

package/packages/mistralai-gcp/src/models/errors/sdkvalidationerror.ts

@@ -1,8 +1,9 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ca7643fc919c
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4/core";
 
 export class SDKValidationError extends Error {
   /**
@@ -41,7 +42,7 @@ export class SDKValidationError extends Error {
    * default error message.
    */
   public pretty(): string {
-    if (this.cause instanceof z.ZodError) {
+    if (this.cause instanceof z.$ZodError) {
       return `${this.rawMessage}\n${formatZodError(this.cause)}`;
     } else {
       return this.toString();
@@ -49,61 +50,6 @@ export class SDKValidationError extends Error {
   }
 }
 
-export function formatZodError(err: z.ZodError, level = 0): string {
-  let pre = "  ".repeat(level);
-  pre = level > 0 ? `│${pre}` : pre;
-  pre += " ".repeat(level);
-
-  let message = "";
-  const append = (str: string) => (message += `\n${pre}${str}`);
-
-  const len = err.issues.length;
-  const headline = len === 1 ? `${len} issue found` : `${len} issues found`;
-
-  if (len) {
-    append(`┌ ${headline}:`);
-  }
-
-  for (const issue of err.issues) {
-    let path = issue.path.join(".");
-    path = path ? `<root>.${path}` : "<root>";
-    append(`│ • [${path}]: ${issue.message} (${issue.code})`);
-    switch (issue.code) {
-      case "invalid_literal":
-      case "invalid_type": {
-        append(`│     Want: ${issue.expected}`);
-        append(`│      Got: ${issue.received}`);
-        break;
-      }
-      case "unrecognized_keys": {
-        append(`│     Keys: ${issue.keys.join(", ")}`);
-        break;
-      }
-      case "invalid_enum_value": {
-        append(`│     Allowed: ${issue.options.join(", ")}`);
-        append(`│         Got: ${issue.received}`);
-        break;
-      }
-      case "invalid_union_discriminator": {
-        append(`│     Allowed: ${issue.options.join(", ")}`);
-        break;
-      }
-      case "invalid_union": {
-        const len = issue.unionErrors.length;
-        append(
-          `│   ✖︎ Attemped to deserialize into one of ${len} union members:`,
-        );
-        issue.unionErrors.forEach((err, i) => {
-          append(`│   ✖︎ Member ${i + 1} of ${len}`);
-          append(`${formatZodError(err, level + 1)}`);
-        });
-      }
-    }
-  }
-
-  if (err.issues.length) {
-    append(`└─*`);
-  }
-
-  return message.slice(1);
+export function formatZodError(err: z.$ZodError): string {
+  return z.prettifyError(err);
 }

package/packages/mistralai-gcp/src/sdk/chat.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c0b89821c0de
  */
 
 import { chatComplete } from "../funcs/chatComplete.js";

package/packages/mistralai-gcp/src/sdk/fim.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 04c83a58db42
  */
 
 import { fimComplete } from "../funcs/fimComplete.js";

package/packages/mistralai-gcp/src/sdk/index.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 769512e38c9c
  */
 
 export * from "./sdk.js";

package/packages/mistralai-gcp/src/sdk/sdk.ts

@@ -1,9 +1,9 @@
 import { GoogleAuth } from "google-auth-library";
 import { SDKOptions } from "../lib/config.js";
 import { ClientSDK } from "../lib/sdks.js";
-import { Chat } from "./chat";
-import { Fim } from "./fim";
-import { SDKHooks } from "../hooks";
+import { Chat } from "./chat.js";
+import { Fim } from "./fim.js";
+import { SDKHooks } from "../hooks/index.js";
 
 export type GoogleCloudOptions = {
   /** The region of the Google Cloud AI Platform endpoint */
@@ -31,7 +31,7 @@ function getModelInfo(model: string): [string, string] {
   return [model, modelId];
 }
 
-export class MistralGoogleCloud extends ClientSDK {
+export class MistralGCP extends ClientSDK {
   constructor(options: SDKOptions & GoogleCloudOptions = {}) {
     let projectId = options.projectId ?? "";
     options.region = options.region ?? "europe-west4";
@@ -47,18 +47,19 @@ export class MistralGoogleCloud extends ClientSDK {
       options.apiKey = async () => {
         const authClient = await auth.getClient();
         const authHeaders = await authClient.getRequestHeaders();
-        const token = authHeaders["Authorization"];
+        const token = authHeaders.get("Authorization");
         if (!token) {
           throw new Error("failed to get Google Cloud API key from the default authorization provider, check you are authenticated");
         }
 
         if (!options.projectId) {
-          if (!authHeaders["x-goog-user-project"]) {
+          const userProject = authHeaders.get("x-goog-user-project");
+          if (!userProject) {
             throw new Error(
-              "no project id available in default google credentials. Please provide a project id in the input arguments to MistralGoogleCloud."
+              "no project id available in default google credentials. Please provide a project id in the input arguments to MistralGCP."
             );
           }
-          projectId = authHeaders["x-goog-user-project"];
+          projectId = userProject;
         }
         return token;
       }

package/packages/mistralai-gcp/src/types/async.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a6d77aac7acb
  */
 
 export type APICall =

package/packages/mistralai-gcp/src/types/blobs.ts

@@ -1,15 +1,17 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 443506f44eea
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 
-export const blobLikeSchema: z.ZodType<Blob, z.ZodTypeDef, Blob> = z.custom<
-  Blob
->(isBlobLike, {
-  message: "expected a Blob, File or Blob-like object",
-  fatal: true,
-});
+export const blobLikeSchema: z.ZodType<Blob, Blob> = z.custom<Blob>(
+  isBlobLike,
+  {
+    message: "expected a Blob, File or Blob-like object",
+    abort: true,
+  },
+);
 
 export function isBlobLike(val: unknown): val is Blob {
   if (val instanceof Blob) {

package/packages/mistralai-gcp/src/types/constdatetime.ts

@@ -1,12 +1,13 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 462c66077cae
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 
 export function constDateTime(
   val: string,
-): z.ZodType<string, z.ZodTypeDef, unknown> {
+): z.ZodType<string, unknown> {
   return z.custom<string>((v) => {
     return (
       typeof v === "string" && new Date(v).getTime() === new Date(val).getTime()

package/packages/mistralai-gcp/src/types/discriminatedUnion.ts

@@ -0,0 +1,96 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fa2cc4692ad9
+ */
+
+import * as z from "zod/v4";
+import { startCountingUnrecognized } from "./unrecognized.js";
+
+const UNKNOWN = Symbol("UNKNOWN");
+
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> =
+  & {
+    [K in Discriminator]: UnknownValue;
+  }
+  & {
+    raw: unknown;
+    isUnknown: true;
+  };
+
+export function isUnknown<Discriminator extends string>(
+  value: unknown,
+): value is Unknown<Discriminator> {
+  return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion<
+  InputDiscriminator extends string,
+  TOptions extends Readonly<Record<string, z.ZodType>>,
+  UnknownValue extends string = "UNKNOWN",
+  OutputDiscriminator extends string = InputDiscriminator,
+>(
+  inputPropertyName: InputDiscriminator,
+  options: TOptions,
+  opts: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+  } = {},
+): z.ZodType<
+  | z.output<TOptions[keyof TOptions]>
+  | Unknown<OutputDiscriminator, UnknownValue>,
+  unknown
+> {
+  const { unknownValue = "UNKNOWN" as UnknownValue, outputPropertyName } = opts;
+  return z.unknown().transform((input) => {
+    const fallback = Object.defineProperties(
+      {
+        raw: input,
+        [outputPropertyName ?? inputPropertyName]: unknownValue,
+        isUnknown: true as const,
+      },
+      { [UNKNOWN]: { value: true, enumerable: false, configurable: false } },
+    );
+
+    const isObject = typeof input === "object" && input !== null;
+    if (!isObject) return fallback;
+
+    const discriminator = input[inputPropertyName as keyof typeof input];
+    if (typeof discriminator !== "string") return fallback;
+    if (!(discriminator in options)) return fallback;
+
+    const schema = options[discriminator];
+    if (!schema) return fallback;
+
+    // Start counters before parsing to track nested unrecognized/zeroDefault values
+    const unrecognizedCtr = startCountingUnrecognized();
+
+    const result = schema.safeParse(input);
+    if (!result.success) {
+      // Parse failed - don't propagate any counts from the failed attempt
+      unrecognizedCtr.end(0);
+
+      return fallback;
+    }
+
+    // Parse succeeded - propagate the actual counts
+    unrecognizedCtr.end();
+
+    if (outputPropertyName) {
+      (result.data as any)[outputPropertyName] = discriminator;
+    }
+
+    return result.data;
+  }) as any;
+}

package/packages/mistralai-gcp/src/types/enums.ts

@@ -1,8 +1,9 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 15455f237990
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { Unrecognized, unrecognized } from "./unrecognized.js";
 
 export type ClosedEnum<T extends Readonly<Record<string, string | number>>> =
@@ -13,7 +14,7 @@ export type OpenEnum<T extends Readonly<Record<string, string | number>>> =
 
 export function inboundSchema<T extends Record<string, string>>(
   enumObj: T,
-): z.ZodType<OpenEnum<T>, z.ZodTypeDef, unknown> {
+): z.ZodType<OpenEnum<T>, unknown> {
   const options = Object.values(enumObj);
   return z.union([
     ...options.map(x => z.literal(x)),
@@ -23,23 +24,23 @@ export function inboundSchema<T extends Record<string, string>>(
 
 export function inboundSchemaInt<T extends Record<string, number | string>>(
   enumObj: T,
-): z.ZodType<OpenEnum<T>, z.ZodTypeDef, unknown> {
+): z.ZodType<OpenEnum<T>, unknown> {
   // For numeric enums, Object.values returns both numbers and string keys
   const options = Object.values(enumObj).filter(v => typeof v === "number");
   return z.union([
     ...options.map(x => z.literal(x)),
-    z.number().int().transform(x => unrecognized(x)),
+    z.int().transform(x => unrecognized(x)),
   ] as any);
 }
 
 export function outboundSchema<T extends Record<string, string>>(
   _: T,
-): z.ZodType<string, z.ZodTypeDef, OpenEnum<T>> {
+): z.ZodType<string, OpenEnum<T>> {
   return z.string() as any;
 }
 
 export function outboundSchemaInt<T extends Record<string, number | string>>(
   _: T,
-): z.ZodType<number, z.ZodTypeDef, OpenEnum<T>> {
-  return z.number().int() as any;
+): z.ZodType<number, OpenEnum<T>> {
+  return z.int() as any;
 }

package/packages/mistralai-gcp/src/types/fp.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: def6f4b9bac5
  */
 
 /**

package/packages/mistralai-gcp/src/types/index.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c7076c75db4b
  */
 
 export { blobLikeSchema, isBlobLike } from "./blobs.js";

package/packages/mistralai-gcp/src/types/operations.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ec774cba8471
  */
 
 import { Result } from "./fp.js";

package/packages/mistralai-gcp/src/types/rfcdate.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 1085f2a578cb
  */
 
 const dateRE = /^\d{4}-\d{2}-\d{2}$/;

package/packages/mistralai-gcp/src/types/smartUnion.ts

@@ -0,0 +1,144 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f6fbdf36f7d2
+ */
+
+// Not needed if lax mode
+import * as z from "zod/v4";
+import { isUnknown as isDiscriminatedUnionUnknown } from "./discriminatedUnion.js";
+import { RFCDate } from "./rfcdate.js";
+import { startCountingUnrecognized } from "./unrecognized.js";
+
+interface Candidate {
+  data: unknown;
+  /** Total number of fields in the parsed data */
+  fieldCount: number;
+  /** Number of fields which only matched due to lax parsing */
+  inexactCount: number;
+  /** Number of fields which defaulted to zero values */
+  zeroDefaultCount: number;
+}
+
+/**
+ * Smart union parser that tries all schemas and returns the best match
+ * based on the number of populated fields.
+ */
+export function smartUnion<
+  Options extends readonly [z.ZodType, z.ZodType, ...z.ZodType[]],
+>(
+  options: Options,
+): z.ZodType<z.output<Options[number]>, z.input<Options[number]>> {
+  return z.unknown().transform((input, ctx) => {
+    const candidates: Candidate[] = [];
+    const errors: z.ZodIssue[][] = options.map(() => []);
+
+    const parentUnrecognizedCtr = startCountingUnrecognized();
+
+    // Filter out invalid options
+    for (const [i, option] of options.entries()) {
+      const unrecognizedCtr = startCountingUnrecognized();
+
+      const result = option.safeParse(input);
+      const inexactCount = unrecognizedCtr.end();
+      const zeroDefaultCount = 0;
+      if (result.success) {
+        candidates.push({
+          data: result.data,
+          inexactCount,
+          zeroDefaultCount,
+          fieldCount: -1, // We'll count this later if needed
+        });
+        continue;
+      }
+      errors[i]!.push(...result.error.issues);
+    }
+
+    // No valid options
+    if (candidates.length === 0) {
+      parentUnrecognizedCtr.end(0);
+      ctx.addIssue({ input: input, code: "invalid_union", errors: errors });
+      return z.NEVER;
+    }
+
+    let best = candidates[0]!;
+
+    // Find the best option
+    for (const candidate of candidates) {
+      // Minor optimization to avoid counting fields if there's only one candidate
+      if (candidates.length > 1) {
+        candidate.fieldCount = countFieldsRecursive(candidate.data);
+      }
+      best = better(candidate, best);
+    }
+
+    // The cost of this union should be the cost of the best candidate not all the candidates
+    parentUnrecognizedCtr.end(best.inexactCount);
+
+    return best.data;
+  }) as any;
+}
+
+function better(a: Candidate, b: Candidate): Candidate {
+  // First prefer exact matches over inexact ones
+  const aIsExact = a.inexactCount === 0;
+  const bIsExact = b.inexactCount === 0;
+  if (aIsExact !== bIsExact) {
+    return aIsExact ? a : b;
+  }
+
+  // Then compare field counts
+  const actualFieldCountA = a.fieldCount - a.zeroDefaultCount;
+  const actualFieldCountB = b.fieldCount - b.zeroDefaultCount;
+  if (actualFieldCountA !== actualFieldCountB) {
+    return actualFieldCountA > actualFieldCountB ? a : b;
+  }
+  return a.inexactCount < b.inexactCount ? a : b;
+}
+
+/**
+ * Counts the number of fields in a parsed value recursively.
+ * @param `parsed` assumed to *not* contain cycles
+ * fieldCount: total number of fields found
+ * inexactCount: number of primitive values that are not unrecognized enum values
+ */
+function countFieldsRecursive(parsed: unknown): number {
+  let fieldCount = 0;
+
+  const queue: unknown[] = [parsed];
+  let index = 0;
+
+  while (index < queue.length) {
+    const value = queue[index++];
+    if (value === undefined || isDiscriminatedUnionUnknown(value)) {
+      continue;
+    }
+
+    // Check if it's a primitive value
+    const type = typeof value;
+    if (
+      value === null
+      || type === "number"
+      || type === "string"
+      || type === "boolean"
+      || type === "bigint"
+      || value instanceof Date
+      || value instanceof RFCDate
+    ) {
+      fieldCount++;
+      continue;
+    }
+
+    // Handle arrays
+    if (Array.isArray(value)) {
+      queue.push(...value);
+      continue;
+    }
+
+    // Handle objects
+    if (type === "object") {
+      queue.push(...Object.values(value));
+    }
+  }
+
+  return fieldCount;
+}

package/packages/mistralai-gcp/src/types/streams.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fce99fe5ef6d
  */
 
 export function isReadableStream<T = Uint8Array>(

package/packages/mistralai-gcp/src/types/unrecognized.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 65e10ddefb77
  */
 
 declare const __brand: unique symbol;

package/src/extra/realtime/connection.ts

@@ -293,8 +293,9 @@ export class RealtimeConnection implements AsyncIterable<RealtimeEvent> {
     }
 
     if ("session" in event) {
-      this.currentSession = event.session;
-      this.currentAudioFormat = event.session.audioFormat;
+      const session = (event as { session: RealtimeTranscriptionSession }).session;
+      this.currentSession = session;
+      this.currentAudioFormat = session.audioFormat;
     }
   }
 }

package/src/extra/structChat.ts

@@ -1,8 +1,81 @@
 import { z } from 'zod';
+import { z as zv4 } from 'zod/v4';
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { ResponseFormat } from "../models/components/responseformat.js";
 import * as components from "../models/components/index.js";
 
+/**
+ * Recursively makes a JSON schema strict-mode compatible:
+ * - Sets additionalProperties: false on all objects
+ * - Makes optional properties required with nullable type
+ * Mirrors Python SDK's rec_strict_json_schema + optional handling.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- operating on raw JSON schema objects
+function makeStrictJsonSchema(node: any): any {
+  if (typeof node !== 'object' || node === null) return node;
+  const result = { ...node };
+
+  if (result.type === 'object' && result.properties && typeof result.properties === 'object') {
+    const required = new Set<string>(Array.isArray(result.required) ? result.required : []);
+    const props: Record<string, any> = {};
+
+    for (const [key, value] of Object.entries(result.properties)) {
+      const processed = makeStrictJsonSchema(value);
+      if (!required.has(key)) {
+        required.add(key);
+        if (Array.isArray(processed.type)) {
+          if (!processed.type.includes('null')) props[key] = { ...processed, type: [...processed.type, 'null'] };
+          else props[key] = processed;
+        } else if (Array.isArray(processed.anyOf)) {
+          if (!processed.anyOf.some((s: any) => s.type === 'null'))
+            props[key] = { ...processed, anyOf: [...processed.anyOf, { type: 'null' }] };
+          else props[key] = processed;
+        } else if (processed.type) {
+          props[key] = { ...processed, type: [processed.type, 'null'] };
+        } else {
+          props[key] = processed;
+        }
+      } else {
+        props[key] = processed;
+      }
+    }
+
+    result.properties = props;
+    result.required = [...required];
+    result.additionalProperties = false;
+  }
+
+  if (result.items) result.items = makeStrictJsonSchema(result.items);
+  for (const key of ['anyOf', 'oneOf', 'allOf']) {
+    if (Array.isArray(result[key]))
+      result[key] = result[key].map(makeStrictJsonSchema);
+  }
+  for (const key of ['$defs', 'definitions']) {
+    if (result[key] && typeof result[key] === 'object') {
+      const defs: Record<string, any> = {};
+      for (const [k, v] of Object.entries(result[key]))
+        defs[k] = makeStrictJsonSchema(v);
+      result[key] = defs;
+    }
+  }
+
+  return result;
+}
+
+function toJsonSchema(schema: z.ZodTypeAny): Record<string, unknown> {
+  let jsonSchema: Record<string, unknown>;
+
+  // Detect Zod v4 schemas by checking for _zod property (v3 schemas have _def only)
+  if ('_zod' in schema) {
+    jsonSchema = zv4.toJSONSchema(schema as any) as Record<string, unknown>;
+  } else {
+    jsonSchema = zodToJsonSchema(schema, { target: "openAi" }) as Record<string, unknown>;
+  }
+
+  delete jsonSchema['$schema'];
+  return makeStrictJsonSchema(jsonSchema);
+}
+
 export function transformToChatCompletionRequest<T extends z.ZodTypeAny>(
   parsedRequest: ParsedChatCompletionRequest<T>
 ): components.ChatCompletionRequest {
@@ -66,7 +139,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 as z.ZodType<any, z.ZodTypeDef, any>);
+  const responseJsonSchema = toJsonSchema(responseFormat);
   // 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"

package/src/funcs/agentsStream.ts

@@ -3,7 +3,7 @@
  * @generated-id: 246290de1817
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { MistralCore } from "../core.js";
 import { encodeJSON } from "../lib/encodings.js";
 import { EventStream } from "../lib/event-streams.js";
@@ -162,11 +162,14 @@ async function $do(
   >(
     M.sse(
       200,
-      z.instanceof(ReadableStream<Uint8Array>)
+      z.custom<ReadableStream<Uint8Array>>(x => x instanceof ReadableStream)
         .transform(stream => {
           return new EventStream(stream, rawEvent => {
-            if (rawEvent.data === "[DONE]") return { done: true };
+            if (rawEvent.data === "[DONE]") {
+              return { done: true, value: undefined };
+            }
             return {
+              done: false,
               value: components.CompletionEvent$inboundSchema.parse(rawEvent),
             };
           });