@mistralai/mistralai 1.9.19 → 1.11.0

package/src/models/components/toolexecutiondoneevent.ts

@@ -21,12 +21,14 @@ export type ToolExecutionDoneEventType = ClosedEnum<
   typeof ToolExecutionDoneEventType
 >;
 
+export type ToolExecutionDoneEventName = BuiltInConnectors | string;
+
 export type ToolExecutionDoneEvent = {
   type?: ToolExecutionDoneEventType | undefined;
   createdAt?: Date | undefined;
   outputIndex?: number | undefined;
   id: string;
-  name: BuiltInConnectors;
+  name: BuiltInConnectors | string;
   info?: { [k: string]: any } | undefined;
 };
 
@@ -51,6 +53,54 @@ export namespace ToolExecutionDoneEventType$ {
   export const outboundSchema = ToolExecutionDoneEventType$outboundSchema;
 }
 
+/** @internal */
+export const ToolExecutionDoneEventName$inboundSchema: z.ZodType<
+  ToolExecutionDoneEventName,
+  z.ZodTypeDef,
+  unknown
+> = z.union([BuiltInConnectors$inboundSchema, z.string()]);
+
+/** @internal */
+export type ToolExecutionDoneEventName$Outbound = string | string;
+
+/** @internal */
+export const ToolExecutionDoneEventName$outboundSchema: z.ZodType<
+  ToolExecutionDoneEventName$Outbound,
+  z.ZodTypeDef,
+  ToolExecutionDoneEventName
+> = z.union([BuiltInConnectors$outboundSchema, z.string()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ToolExecutionDoneEventName$ {
+  /** @deprecated use `ToolExecutionDoneEventName$inboundSchema` instead. */
+  export const inboundSchema = ToolExecutionDoneEventName$inboundSchema;
+  /** @deprecated use `ToolExecutionDoneEventName$outboundSchema` instead. */
+  export const outboundSchema = ToolExecutionDoneEventName$outboundSchema;
+  /** @deprecated use `ToolExecutionDoneEventName$Outbound` instead. */
+  export type Outbound = ToolExecutionDoneEventName$Outbound;
+}
+
+export function toolExecutionDoneEventNameToJSON(
+  toolExecutionDoneEventName: ToolExecutionDoneEventName,
+): string {
+  return JSON.stringify(
+    ToolExecutionDoneEventName$outboundSchema.parse(toolExecutionDoneEventName),
+  );
+}
+
+export function toolExecutionDoneEventNameFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolExecutionDoneEventName, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolExecutionDoneEventName$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolExecutionDoneEventName' from JSON`,
+  );
+}
+
 /** @internal */
 export const ToolExecutionDoneEvent$inboundSchema: z.ZodType<
   ToolExecutionDoneEvent,
@@ -62,7 +112,7 @@ export const ToolExecutionDoneEvent$inboundSchema: z.ZodType<
     .optional(),
   output_index: z.number().int().default(0),
   id: z.string(),
-  name: BuiltInConnectors$inboundSchema,
+  name: z.union([BuiltInConnectors$inboundSchema, z.string()]),
   info: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -77,7 +127,7 @@ export type ToolExecutionDoneEvent$Outbound = {
   created_at?: string | undefined;
   output_index: number;
   id: string;
-  name: string;
+  name: string | string;
   info?: { [k: string]: any } | undefined;
 };
 
@@ -93,7 +143,7 @@ export const ToolExecutionDoneEvent$outboundSchema: z.ZodType<
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   outputIndex: z.number().int().default(0),
   id: z.string(),
-  name: BuiltInConnectors$outboundSchema,
+  name: z.union([BuiltInConnectors$outboundSchema, z.string()]),
   info: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/toolexecutionentry.ts

@@ -26,13 +26,15 @@ export const ToolExecutionEntryType = {
 } as const;
 export type ToolExecutionEntryType = ClosedEnum<typeof ToolExecutionEntryType>;
 
+export type Name = BuiltInConnectors | string;
+
 export type ToolExecutionEntry = {
   object?: ToolExecutionEntryObject | undefined;
   type?: ToolExecutionEntryType | undefined;
   createdAt?: Date | undefined;
   completedAt?: Date | null | undefined;
   id?: string | undefined;
-  name: BuiltInConnectors;
+  name: BuiltInConnectors | string;
   arguments: string;
   info?: { [k: string]: any } | undefined;
 };
@@ -79,6 +81,44 @@ export namespace ToolExecutionEntryType$ {
   export const outboundSchema = ToolExecutionEntryType$outboundSchema;
 }
 
+/** @internal */
+export const Name$inboundSchema: z.ZodType<Name, z.ZodTypeDef, unknown> = z
+  .union([BuiltInConnectors$inboundSchema, z.string()]);
+
+/** @internal */
+export type Name$Outbound = string | string;
+
+/** @internal */
+export const Name$outboundSchema: z.ZodType<Name$Outbound, z.ZodTypeDef, Name> =
+  z.union([BuiltInConnectors$outboundSchema, z.string()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Name$ {
+  /** @deprecated use `Name$inboundSchema` instead. */
+  export const inboundSchema = Name$inboundSchema;
+  /** @deprecated use `Name$outboundSchema` instead. */
+  export const outboundSchema = Name$outboundSchema;
+  /** @deprecated use `Name$Outbound` instead. */
+  export type Outbound = Name$Outbound;
+}
+
+export function nameToJSON(name: Name): string {
+  return JSON.stringify(Name$outboundSchema.parse(name));
+}
+
+export function nameFromJSON(
+  jsonString: string,
+): SafeParseResult<Name, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Name$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Name' from JSON`,
+  );
+}
+
 /** @internal */
 export const ToolExecutionEntry$inboundSchema: z.ZodType<
   ToolExecutionEntry,
@@ -93,7 +133,7 @@ export const ToolExecutionEntry$inboundSchema: z.ZodType<
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ).optional(),
   id: z.string().optional(),
-  name: BuiltInConnectors$inboundSchema,
+  name: z.union([BuiltInConnectors$inboundSchema, z.string()]),
   arguments: z.string(),
   info: z.record(z.any()).optional(),
 }).transform((v) => {
@@ -110,7 +150,7 @@ export type ToolExecutionEntry$Outbound = {
   created_at?: string | undefined;
   completed_at?: string | null | undefined;
   id?: string | undefined;
-  name: string;
+  name: string | string;
   arguments: string;
   info?: { [k: string]: any } | undefined;
 };
@@ -126,7 +166,7 @@ export const ToolExecutionEntry$outboundSchema: z.ZodType<
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   completedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
   id: z.string().optional(),
-  name: BuiltInConnectors$outboundSchema,
+  name: z.union([BuiltInConnectors$outboundSchema, z.string()]),
   arguments: z.string(),
   info: z.record(z.any()).optional(),
 }).transform((v) => {

package/src/models/components/toolexecutionstartedevent.ts

@@ -21,12 +21,14 @@ export type ToolExecutionStartedEventType = ClosedEnum<
   typeof ToolExecutionStartedEventType
 >;
 
+export type ToolExecutionStartedEventName = BuiltInConnectors | string;
+
 export type ToolExecutionStartedEvent = {
   type?: ToolExecutionStartedEventType | undefined;
   createdAt?: Date | undefined;
   outputIndex?: number | undefined;
   id: string;
-  name: BuiltInConnectors;
+  name: BuiltInConnectors | string;
   arguments: string;
 };
 
@@ -51,6 +53,56 @@ export namespace ToolExecutionStartedEventType$ {
   export const outboundSchema = ToolExecutionStartedEventType$outboundSchema;
 }
 
+/** @internal */
+export const ToolExecutionStartedEventName$inboundSchema: z.ZodType<
+  ToolExecutionStartedEventName,
+  z.ZodTypeDef,
+  unknown
+> = z.union([BuiltInConnectors$inboundSchema, z.string()]);
+
+/** @internal */
+export type ToolExecutionStartedEventName$Outbound = string | string;
+
+/** @internal */
+export const ToolExecutionStartedEventName$outboundSchema: z.ZodType<
+  ToolExecutionStartedEventName$Outbound,
+  z.ZodTypeDef,
+  ToolExecutionStartedEventName
+> = z.union([BuiltInConnectors$outboundSchema, z.string()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ToolExecutionStartedEventName$ {
+  /** @deprecated use `ToolExecutionStartedEventName$inboundSchema` instead. */
+  export const inboundSchema = ToolExecutionStartedEventName$inboundSchema;
+  /** @deprecated use `ToolExecutionStartedEventName$outboundSchema` instead. */
+  export const outboundSchema = ToolExecutionStartedEventName$outboundSchema;
+  /** @deprecated use `ToolExecutionStartedEventName$Outbound` instead. */
+  export type Outbound = ToolExecutionStartedEventName$Outbound;
+}
+
+export function toolExecutionStartedEventNameToJSON(
+  toolExecutionStartedEventName: ToolExecutionStartedEventName,
+): string {
+  return JSON.stringify(
+    ToolExecutionStartedEventName$outboundSchema.parse(
+      toolExecutionStartedEventName,
+    ),
+  );
+}
+
+export function toolExecutionStartedEventNameFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolExecutionStartedEventName, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolExecutionStartedEventName$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolExecutionStartedEventName' from JSON`,
+  );
+}
+
 /** @internal */
 export const ToolExecutionStartedEvent$inboundSchema: z.ZodType<
   ToolExecutionStartedEvent,
@@ -64,7 +116,7 @@ export const ToolExecutionStartedEvent$inboundSchema: z.ZodType<
     .optional(),
   output_index: z.number().int().default(0),
   id: z.string(),
-  name: BuiltInConnectors$inboundSchema,
+  name: z.union([BuiltInConnectors$inboundSchema, z.string()]),
   arguments: z.string(),
 }).transform((v) => {
   return remap$(v, {
@@ -79,7 +131,7 @@ export type ToolExecutionStartedEvent$Outbound = {
   created_at?: string | undefined;
   output_index: number;
   id: string;
-  name: string;
+  name: string | string;
   arguments: string;
 };
 
@@ -95,7 +147,7 @@ export const ToolExecutionStartedEvent$outboundSchema: z.ZodType<
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   outputIndex: z.number().int().default(0),
   id: z.string(),
-  name: BuiltInConnectors$outboundSchema,
+  name: z.union([BuiltInConnectors$outboundSchema, z.string()]),
   arguments: z.string(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/transcriptionstreamevents.ts

@@ -37,18 +37,18 @@ import {
 } from "./transcriptionstreamtextdelta.js";
 
 export type TranscriptionStreamEventsData =
-  | (TranscriptionStreamLanguage & { type: "transcription.language" })
-  | (TranscriptionStreamTextDelta & { type: "transcription.text.delta" })
+  | (TranscriptionStreamDone & { type: "transcription.done" })
   | (TranscriptionStreamSegmentDelta & { type: "transcription.segment" })
-  | (TranscriptionStreamDone & { type: "transcription.done" });
+  | (TranscriptionStreamLanguage & { type: "transcription.language" })
+  | (TranscriptionStreamTextDelta & { type: "transcription.text.delta" });
 
 export type TranscriptionStreamEvents = {
   event: TranscriptionStreamEventTypes;
   data:
-    | (TranscriptionStreamLanguage & { type: "transcription.language" })
-    | (TranscriptionStreamTextDelta & { type: "transcription.text.delta" })
+    | (TranscriptionStreamDone & { type: "transcription.done" })
     | (TranscriptionStreamSegmentDelta & { type: "transcription.segment" })
-    | (TranscriptionStreamDone & { type: "transcription.done" });
+    | (TranscriptionStreamLanguage & { type: "transcription.language" })
+    | (TranscriptionStreamTextDelta & { type: "transcription.text.delta" });
 };
 
 /** @internal */
@@ -57,38 +57,38 @@ export const TranscriptionStreamEventsData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  TranscriptionStreamLanguage$inboundSchema.and(
-    z.object({ type: z.literal("transcription.language") }).transform((v) => ({
+  TranscriptionStreamDone$inboundSchema.and(
+    z.object({ type: z.literal("transcription.done") }).transform((v) => ({
       type: v.type,
     })),
   ),
-  TranscriptionStreamTextDelta$inboundSchema.and(
-    z.object({ type: z.literal("transcription.text.delta") }).transform((
-      v,
-    ) => ({ type: v.type })),
-  ),
   TranscriptionStreamSegmentDelta$inboundSchema.and(
     z.object({ type: z.literal("transcription.segment") }).transform((v) => ({
       type: v.type,
     })),
   ),
-  TranscriptionStreamDone$inboundSchema.and(
-    z.object({ type: z.literal("transcription.done") }).transform((v) => ({
+  TranscriptionStreamLanguage$inboundSchema.and(
+    z.object({ type: z.literal("transcription.language") }).transform((v) => ({
       type: v.type,
     })),
   ),
+  TranscriptionStreamTextDelta$inboundSchema.and(
+    z.object({ type: z.literal("transcription.text.delta") }).transform((
+      v,
+    ) => ({ type: v.type })),
+  ),
 ]);
 
 /** @internal */
 export type TranscriptionStreamEventsData$Outbound =
-  | (TranscriptionStreamLanguage$Outbound & { type: "transcription.language" })
-  | (TranscriptionStreamTextDelta$Outbound & {
-    type: "transcription.text.delta";
-  })
+  | (TranscriptionStreamDone$Outbound & { type: "transcription.done" })
   | (TranscriptionStreamSegmentDelta$Outbound & {
     type: "transcription.segment";
   })
-  | (TranscriptionStreamDone$Outbound & { type: "transcription.done" });
+  | (TranscriptionStreamLanguage$Outbound & { type: "transcription.language" })
+  | (TranscriptionStreamTextDelta$Outbound & {
+    type: "transcription.text.delta";
+  });
 
 /** @internal */
 export const TranscriptionStreamEventsData$outboundSchema: z.ZodType<
@@ -96,26 +96,26 @@ export const TranscriptionStreamEventsData$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   TranscriptionStreamEventsData
 > = z.union([
-  TranscriptionStreamLanguage$outboundSchema.and(
-    z.object({ type: z.literal("transcription.language") }).transform((v) => ({
+  TranscriptionStreamDone$outboundSchema.and(
+    z.object({ type: z.literal("transcription.done") }).transform((v) => ({
       type: v.type,
     })),
   ),
-  TranscriptionStreamTextDelta$outboundSchema.and(
-    z.object({ type: z.literal("transcription.text.delta") }).transform((
-      v,
-    ) => ({ type: v.type })),
-  ),
   TranscriptionStreamSegmentDelta$outboundSchema.and(
     z.object({ type: z.literal("transcription.segment") }).transform((v) => ({
       type: v.type,
     })),
   ),
-  TranscriptionStreamDone$outboundSchema.and(
-    z.object({ type: z.literal("transcription.done") }).transform((v) => ({
+  TranscriptionStreamLanguage$outboundSchema.and(
+    z.object({ type: z.literal("transcription.language") }).transform((v) => ({
       type: v.type,
     })),
   ),
+  TranscriptionStreamTextDelta$outboundSchema.and(
+    z.object({ type: z.literal("transcription.text.delta") }).transform((
+      v,
+    ) => ({ type: v.type })),
+  ),
 ]);
 
 /**
@@ -170,6 +170,16 @@ export const TranscriptionStreamEvents$inboundSchema: z.ZodType<
     }
   }).pipe(
     z.union([
+      TranscriptionStreamDone$inboundSchema.and(
+        z.object({ type: z.literal("transcription.done") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      TranscriptionStreamSegmentDelta$inboundSchema.and(
+        z.object({ type: z.literal("transcription.segment") }).transform((
+          v,
+        ) => ({ type: v.type })),
+      ),
       TranscriptionStreamLanguage$inboundSchema.and(
         z.object({ type: z.literal("transcription.language") }).transform((
           v,
@@ -180,16 +190,6 @@ export const TranscriptionStreamEvents$inboundSchema: z.ZodType<
           v,
         ) => ({ type: v.type })),
       ),
-      TranscriptionStreamSegmentDelta$inboundSchema.and(
-        z.object({ type: z.literal("transcription.segment") }).transform((
-          v,
-        ) => ({ type: v.type })),
-      ),
-      TranscriptionStreamDone$inboundSchema.and(
-        z.object({ type: z.literal("transcription.done") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
     ]),
   ),
 });
@@ -198,16 +198,16 @@ export const TranscriptionStreamEvents$inboundSchema: z.ZodType<
 export type TranscriptionStreamEvents$Outbound = {
   event: string;
   data:
+    | (TranscriptionStreamDone$Outbound & { type: "transcription.done" })
+    | (TranscriptionStreamSegmentDelta$Outbound & {
+      type: "transcription.segment";
+    })
     | (TranscriptionStreamLanguage$Outbound & {
       type: "transcription.language";
     })
     | (TranscriptionStreamTextDelta$Outbound & {
       type: "transcription.text.delta";
-    })
-    | (TranscriptionStreamSegmentDelta$Outbound & {
-      type: "transcription.segment";
-    })
-    | (TranscriptionStreamDone$Outbound & { type: "transcription.done" });
+    });
 };
 
 /** @internal */
@@ -218,6 +218,16 @@ export const TranscriptionStreamEvents$outboundSchema: z.ZodType<
 > = z.object({
   event: TranscriptionStreamEventTypes$outboundSchema,
   data: z.union([
+    TranscriptionStreamDone$outboundSchema.and(
+      z.object({ type: z.literal("transcription.done") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    TranscriptionStreamSegmentDelta$outboundSchema.and(
+      z.object({ type: z.literal("transcription.segment") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
     TranscriptionStreamLanguage$outboundSchema.and(
       z.object({ type: z.literal("transcription.language") }).transform((
         v,
@@ -228,16 +238,6 @@ export const TranscriptionStreamEvents$outboundSchema: z.ZodType<
         v,
       ) => ({ type: v.type })),
     ),
-    TranscriptionStreamSegmentDelta$outboundSchema.and(
-      z.object({ type: z.literal("transcription.segment") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
-    TranscriptionStreamDone$outboundSchema.and(
-      z.object({ type: z.literal("transcription.done") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
   ]),
 });
 

package/src/models/errors/httpvalidationerror.ts

@@ -4,24 +4,27 @@
 
 import * as z from "zod";
 import * as components from "../components/index.js";
+import { MistralError } from "./mistralerror.js";
 
 export type HTTPValidationErrorData = {
   detail?: Array<components.ValidationError> | undefined;
 };
 
-export class HTTPValidationError extends Error {
+export class HTTPValidationError extends MistralError {
   detail?: Array<components.ValidationError> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: HTTPValidationErrorData;
 
-  constructor(err: HTTPValidationErrorData) {
+  constructor(
+    err: HTTPValidationErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     if (err.detail != null) this.detail = err.detail;
 
     this.name = "HTTPValidationError";
@@ -35,9 +38,16 @@ export const HTTPValidationError$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   detail: z.array(components.ValidationError$inboundSchema).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new HTTPValidationError(v);
+    return new HTTPValidationError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/index.ts

@@ -4,5 +4,6 @@
 
 export * from "./httpclienterrors.js";
 export * from "./httpvalidationerror.js";
+export * from "./responsevalidationerror.js";
 export * from "./sdkerror.js";
 export * from "./sdkvalidationerror.js";

package/src/models/errors/mistralerror.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/** The base class for all HTTP error responses */
+export class MistralError extends Error {
+  /** HTTP status code */
+  public readonly statusCode: number;
+  /** HTTP body */
+  public readonly body: string;
+  /** HTTP headers */
+  public readonly headers: Headers;
+  /** HTTP content type */
+  public readonly contentType: string;
+  /** Raw response */
+  public readonly rawResponse: Response;
+
+  constructor(
+    message: string,
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
+  ) {
+    super(message);
+    this.statusCode = httpMeta.response.status;
+    this.body = httpMeta.body;
+    this.headers = httpMeta.response.headers;
+    this.contentType = httpMeta.response.headers.get("content-type") || "";
+    this.rawResponse = httpMeta.response;
+
+    this.name = "MistralError";
+  }
+}

package/src/models/errors/responsevalidationerror.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { MistralError } from "./mistralerror.js";
+import { formatZodError } from "./sdkvalidationerror.js";
+
+export class ResponseValidationError extends MistralError {
+  /**
+   * The raw value that failed validation.
+   */
+  public readonly rawValue: unknown;
+
+  /**
+   * The raw message that failed validation.
+   */
+  public readonly rawMessage: unknown;
+
+  constructor(
+    message: string,
+    extra: {
+      response: Response;
+      request: Request;
+      body: string;
+      cause: unknown;
+      rawValue: unknown;
+      rawMessage: unknown;
+    },
+  ) {
+    super(message, extra);
+    this.name = "ResponseValidationError";
+    this.cause = extra.cause;
+    this.rawValue = extra.rawValue;
+    this.rawMessage = extra.rawMessage;
+  }
+
+  /**
+   * Return a pretty-formatted error message if the underlying validation error
+   * is a ZodError or some other recognized error type, otherwise return the
+   * default error message.
+   */
+  public pretty(): string {
+    if (this.cause instanceof z.ZodError) {
+      return `${this.rawMessage}\n${formatZodError(this.cause)}`;
+    } else {
+      return this.toString();
+    }
+  }
+}

package/src/models/errors/sdkerror.ts

@@ -2,26 +2,39 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-export class SDKError extends Error {
-  public readonly statusCode: number;
-  public readonly contentType: string;
+import { MistralError } from "./mistralerror.js";
 
+/** The fallback error class if no more specific error class is matched */
+export class SDKError extends MistralError {
   constructor(
     message: string,
-    public readonly rawResponse: Response,
-    public readonly body: string = "",
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
   ) {
-    const statusCode = rawResponse.status;
-    const contentType = rawResponse.headers.get("content-type") || "";
-    const bodyString = body.length > 0 ? `\n${body}` : "";
-
-    super(
-      `${message}: Status ${statusCode} Content-Type ${contentType} Body ${bodyString}`,
-    );
-
-    this.statusCode = statusCode;
-    this.contentType = contentType;
-
+    if (message) {
+      message += `: `;
+    }
+    message += `Status ${httpMeta.response.status}`;
+    const contentType = httpMeta.response.headers.get("content-type") || `""`;
+    if (contentType !== "application/json") {
+      message += ` Content-Type ${
+        contentType.includes(" ") ? `"${contentType}"` : contentType
+      }`;
+    }
+    const body = httpMeta.body || `""`;
+    message += body.length > 100 ? "\n" : ". ";
+    let bodyDisplay = body;
+    if (body.length > 10000) {
+      const truncated = body.substring(0, 10000);
+      const remaining = body.length - 10000;
+      bodyDisplay = `${truncated}...and ${remaining} more chars`;
+    }
+    message += `Body: ${bodyDisplay}`;
+    message = message.trim();
+    super(message, httpMeta);
     this.name = "SDKError";
   }
 }