modelfusion 0.109.0 → 0.111.0

package/model-provider/lmnt/LmntSpeechModel.cjs

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LmntSpeechModel = void 0;
-const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const LmntApiConfiguration_js_1 = require("./LmntApiConfiguration.cjs");
-const LmntError_js_1 = require("./LmntError.cjs");
 /**
  * Synthesize speech using the LMNT API.
  *
- * @see https://www.lmnt.com/docs/rest/#synthesize-speech
+ * @see https://docs.lmnt.com/api-reference/speech/synthesize-speech-1
  */
 class LmntSpeechModel extends AbstractModel_js_1.AbstractModel {
     constructor(settings) {
@@ -25,14 +26,44 @@ class LmntSpeechModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
+        const api = this.settings.api ?? new LmntApiConfiguration_js_1.LmntApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: this.settings.api?.retry,
-            throttle: this.settings.api?.throttle,
-            call: async () => callLmntTextToSpeechAPI({
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                text,
-            }),
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => {
+                const formData = new FormData();
+                formData.append("text", text);
+                formData.append("voice", this.settings.voice);
+                formData.append("format", "mp3");
+                formData.append("return_durations", "true");
+                if (this.settings.speed != null) {
+                    formData.append("speed", this.settings.speed.toString());
+                }
+                if (this.settings.seed != null) {
+                    formData.append("seed", this.settings.seed.toString());
+                }
+                if (this.settings.length != null) {
+                    formData.append("length", this.settings.length.toString());
+                }
+                return (0, postToApi_js_1.postToApi)({
+                    url: api.assembleUrl(`/ai/speech`),
+                    headers: api.headers,
+                    body: {
+                        content: formData,
+                        values: {
+                            text,
+                            voice: this.settings.voice,
+                            speed: this.settings.speed,
+                            seed: this.settings.seed,
+                            length: this.settings.length,
+                        },
+                    },
+                    failedResponseHandler: (0, postToApi_js_1.createTextErrorResponseHandler)(),
+                    successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(lmntSpeechResponseSchema)),
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
@@ -43,8 +74,9 @@ class LmntSpeechModel extends AbstractModel_js_1.AbstractModel {
             length: this.settings.length,
         };
     }
-    doGenerateSpeechStandard(text, options) {
-        return this.callAPI(text, options);
+    async doGenerateSpeechStandard(text, options) {
+        const response = await this.callAPI(text, options);
+        return Buffer.from(response.audio, "base64");
     }
     withSettings(additionalSettings) {
         return new LmntSpeechModel({
@@ -54,32 +86,12 @@ class LmntSpeechModel extends AbstractModel_js_1.AbstractModel {
     }
 }
 exports.LmntSpeechModel = LmntSpeechModel;
-async function callLmntTextToSpeechAPI({ api = new LmntApiConfiguration_js_1.LmntApiConfiguration(), abortSignal, text, voice, speed, seed, length, }) {
-    const formData = new FormData();
-    formData.append("text", text);
-    formData.append("voice", voice);
-    formData.append("format", "mp3");
-    if (speed != null)
-        formData.append("speed", speed.toString());
-    if (seed != null)
-        formData.append("seed", seed.toString());
-    if (length != null)
-        formData.append("length", length.toString());
-    return (0, postToApi_js_1.postToApi)({
-        url: api.assembleUrl(`/synthesize`),
-        headers: api.headers,
-        body: {
-            content: formData,
-            values: {
-                text,
-                voice,
-                speed,
-                seed,
-                length,
-            },
-        },
-        failedResponseHandler: LmntError_js_1.failedLmntCallResponseHandler,
-        successfulResponseHandler: (0, postToApi_js_1.createAudioMpegResponseHandler)(),
-        abortSignal,
-    });
-}
+const lmntSpeechResponseSchema = zod_1.z.object({
+    audio: zod_1.z.string(),
+    durations: zod_1.z.array(zod_1.z.object({
+        duration: zod_1.z.number(),
+        start: zod_1.z.number(),
+        text: zod_1.z.string(),
+    })),
+    seed: zod_1.z.number(),
+});

package/model-provider/lmnt/LmntSpeechModel.d.ts

@@ -1,19 +1,32 @@
 /// <reference types="node" />
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
+import { z } from "zod";
 import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { SpeechGenerationModel, SpeechGenerationModelSettings } from "../../model-function/generate-speech/SpeechGenerationModel.js";
 export interface LmntSpeechModelSettings extends SpeechGenerationModelSettings {
     api?: ApiConfiguration;
+    /**
+     * The voice id of the voice to use for synthesis.
+     */
     voice: string;
+    /**
+     * The talking speed of the generated speech. A Floating point value between 0.25 (slow) and 2.0 (fast); defaults to 1.0
+     */
     speed?: number;
+    /**
+     * Seed used to specify a different take; defaults to random
+     */
     seed?: number;
+    /**
+     * Produce speech of this length in seconds; maximum 300.0 (5 minutes)
+     */
     length?: number;
 }
 /**
  * Synthesize speech using the LMNT API.
  *
- * @see https://www.lmnt.com/docs/rest/#synthesize-speech
+ * @see https://docs.lmnt.com/api-reference/speech/synthesize-speech-1
  */
 export declare class LmntSpeechModel extends AbstractModel<LmntSpeechModelSettings> implements SpeechGenerationModel<LmntSpeechModelSettings> {
     constructor(settings: LmntSpeechModelSettings);
@@ -24,3 +37,38 @@ export declare class LmntSpeechModel extends AbstractModel<LmntSpeechModelSettin
     doGenerateSpeechStandard(text: string, options?: FunctionOptions): Promise<Buffer>;
     withSettings(additionalSettings: Partial<LmntSpeechModelSettings>): this;
 }
+declare const lmntSpeechResponseSchema: z.ZodObject<{
+    audio: z.ZodString;
+    durations: z.ZodArray<z.ZodObject<{
+        duration: z.ZodNumber;
+        start: z.ZodNumber;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        duration: number;
+        start: number;
+    }, {
+        text: string;
+        duration: number;
+        start: number;
+    }>, "many">;
+    seed: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    seed: number;
+    audio: string;
+    durations: {
+        text: string;
+        duration: number;
+        start: number;
+    }[];
+}, {
+    seed: number;
+    audio: string;
+    durations: {
+        text: string;
+        duration: number;
+        start: number;
+    }[];
+}>;
+export type LmntSpeechResponse = z.infer<typeof lmntSpeechResponseSchema>;
+export {};

package/model-provider/lmnt/LmntSpeechModel.js

@@ -1,12 +1,13 @@
-import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
-import { createAudioMpegResponseHandler, postToApi, } from "../../core/api/postToApi.js";
+import { createJsonResponseHandler, createTextErrorResponseHandler, postToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { LmntApiConfiguration } from "./LmntApiConfiguration.js";
-import { failedLmntCallResponseHandler } from "./LmntError.js";
 /**
  * Synthesize speech using the LMNT API.
  *
- * @see https://www.lmnt.com/docs/rest/#synthesize-speech
+ * @see https://docs.lmnt.com/api-reference/speech/synthesize-speech-1
  */
 export class LmntSpeechModel extends AbstractModel {
     constructor(settings) {
@@ -22,14 +23,44 @@ export class LmntSpeechModel extends AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
+        const api = this.settings.api ?? new LmntApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return callWithRetryAndThrottle({
-            retry: this.settings.api?.retry,
-            throttle: this.settings.api?.throttle,
-            call: async () => callLmntTextToSpeechAPI({
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                text,
-            }),
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => {
+                const formData = new FormData();
+                formData.append("text", text);
+                formData.append("voice", this.settings.voice);
+                formData.append("format", "mp3");
+                formData.append("return_durations", "true");
+                if (this.settings.speed != null) {
+                    formData.append("speed", this.settings.speed.toString());
+                }
+                if (this.settings.seed != null) {
+                    formData.append("seed", this.settings.seed.toString());
+                }
+                if (this.settings.length != null) {
+                    formData.append("length", this.settings.length.toString());
+                }
+                return postToApi({
+                    url: api.assembleUrl(`/ai/speech`),
+                    headers: api.headers,
+                    body: {
+                        content: formData,
+                        values: {
+                            text,
+                            voice: this.settings.voice,
+                            speed: this.settings.speed,
+                            seed: this.settings.seed,
+                            length: this.settings.length,
+                        },
+                    },
+                    failedResponseHandler: createTextErrorResponseHandler(),
+                    successfulResponseHandler: createJsonResponseHandler(zodSchema(lmntSpeechResponseSchema)),
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
@@ -40,8 +71,9 @@ export class LmntSpeechModel extends AbstractModel {
             length: this.settings.length,
         };
     }
-    doGenerateSpeechStandard(text, options) {
-        return this.callAPI(text, options);
+    async doGenerateSpeechStandard(text, options) {
+        const response = await this.callAPI(text, options);
+        return Buffer.from(response.audio, "base64");
     }
     withSettings(additionalSettings) {
         return new LmntSpeechModel({
@@ -50,32 +82,12 @@ export class LmntSpeechModel extends AbstractModel {
         });
     }
 }
-async function callLmntTextToSpeechAPI({ api = new LmntApiConfiguration(), abortSignal, text, voice, speed, seed, length, }) {
-    const formData = new FormData();
-    formData.append("text", text);
-    formData.append("voice", voice);
-    formData.append("format", "mp3");
-    if (speed != null)
-        formData.append("speed", speed.toString());
-    if (seed != null)
-        formData.append("seed", seed.toString());
-    if (length != null)
-        formData.append("length", length.toString());
-    return postToApi({
-        url: api.assembleUrl(`/synthesize`),
-        headers: api.headers,
-        body: {
-            content: formData,
-            values: {
-                text,
-                voice,
-                speed,
-                seed,
-                length,
-            },
-        },
-        failedResponseHandler: failedLmntCallResponseHandler,
-        successfulResponseHandler: createAudioMpegResponseHandler(),
-        abortSignal,
-    });
-}
+const lmntSpeechResponseSchema = z.object({
+    audio: z.string(),
+    durations: z.array(z.object({
+        duration: z.number(),
+        start: z.number(),
+        text: z.string(),
+    })),
+    seed: z.number(),
+});

package/model-provider/mistral/MistralApiConfiguration.cjs

@@ -3,19 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MistralApiConfiguration = void 0;
 const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
 const loadApiKey_js_1 = require("../../core/api/loadApiKey.cjs");
-class MistralApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://api.mistral.ai/v1", apiKey, retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the Mistral API.
+ * It calls the API at https://api.mistral.ai/v1 and uses the `MISTRAL_API_KEY` env variable by default.
+ */
+class MistralApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfigurationWithDefaults {
+    constructor(settings = {}) {
         super({
-            baseUrl,
+            ...settings,
             headers: {
                 Authorization: `Bearer ${(0, loadApiKey_js_1.loadApiKey)({
-                    apiKey,
+                    apiKey: settings.apiKey,
                     environmentVariableName: "MISTRAL_API_KEY",
                     description: "Mistral",
                 })}`,
             },
-            retry,
-            throttle,
+            baseUrlDefaults: {
+                protocol: "https",
+                host: "api.mistral.ai",
+                port: "443",
+                path: "/v1",
+            },
         });
     }
 }

package/model-provider/mistral/MistralApiConfiguration.d.ts

@@ -1,12 +1,10 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
-import { RetryFunction } from "../../core/api/RetryFunction.js";
-import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
-export type MistralApiConfigurationSettings = {
-    baseUrl?: string;
-    apiKey?: string;
-    retry?: RetryFunction;
-    throttle?: ThrottleFunction;
-};
-export declare class MistralApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl, apiKey, retry, throttle, }?: MistralApiConfigurationSettings);
+import { BaseUrlApiConfigurationWithDefaults, PartialBaseUrlPartsApiConfigurationOptions } from "../../core/api/BaseUrlApiConfiguration.js";
+/**
+ * Creates an API configuration for the Mistral API.
+ * It calls the API at https://api.mistral.ai/v1 and uses the `MISTRAL_API_KEY` env variable by default.
+ */
+export declare class MistralApiConfiguration extends BaseUrlApiConfigurationWithDefaults {
+    constructor(settings?: PartialBaseUrlPartsApiConfigurationOptions & {
+        apiKey?: string;
+    });
 }

package/model-provider/mistral/MistralApiConfiguration.js

@@ -1,18 +1,26 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { BaseUrlApiConfigurationWithDefaults, } from "../../core/api/BaseUrlApiConfiguration.js";
 import { loadApiKey } from "../../core/api/loadApiKey.js";
-export class MistralApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://api.mistral.ai/v1", apiKey, retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the Mistral API.
+ * It calls the API at https://api.mistral.ai/v1 and uses the `MISTRAL_API_KEY` env variable by default.
+ */
+export class MistralApiConfiguration extends BaseUrlApiConfigurationWithDefaults {
+    constructor(settings = {}) {
         super({
-            baseUrl,
+            ...settings,
             headers: {
                 Authorization: `Bearer ${loadApiKey({
-                    apiKey,
+                    apiKey: settings.apiKey,
                     environmentVariableName: "MISTRAL_API_KEY",
                     description: "Mistral",
                 })}`,
             },
-            retry,
-            throttle,
+            baseUrlDefaults: {
+                protocol: "https",
+                host: "api.mistral.ai",
+                port: "443",
+                path: "/v1",
+            },
         });
     }
 }

package/model-provider/mistral/MistralChatModel.cjs

@@ -162,7 +162,7 @@ const mistralChatResponseSchema = zod_1.z.object({
         total_tokens: zod_1.z.number(),
     }),
 });
-const mistralChatStreamChunkSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
+const mistralChatStreamChunkSchema = zod_1.z.object({
     id: zod_1.z.string(),
     object: zod_1.z.string().optional(),
     created: zod_1.z.number().optional(),
@@ -178,20 +178,20 @@ const mistralChatStreamChunkSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object
             .nullable()
             .optional(),
     })),
-}));
+});
 exports.MistralChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
      */
     json: {
         stream: false,
-        handler: (0, postToApi_js_1.createJsonResponseHandler)(mistralChatResponseSchema),
+        handler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(mistralChatResponseSchema)),
     },
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
     textDeltaIterable: {
         stream: true,
-        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)(mistralChatStreamChunkSchema),
+        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)((0, ZodSchema_js_1.zodSchema)(mistralChatStreamChunkSchema)),
     },
 };

package/model-provider/mistral/MistralChatModel.d.ts

@@ -2,7 +2,6 @@ import { z } from "zod";
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
 import { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
@@ -199,7 +198,53 @@ declare const mistralChatResponseSchema: z.ZodObject<{
     }[];
 }>;
 export type MistralChatResponse = z.infer<typeof mistralChatResponseSchema>;
-declare const mistralChatStreamChunkSchema: ZodSchema<{
+declare const mistralChatStreamChunkSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodOptional<z.ZodString>;
+    created: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        delta: z.ZodObject<{
+            role: z.ZodNullable<z.ZodOptional<z.ZodEnum<["assistant", "user"]>>>;
+            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            role?: "user" | "assistant" | null | undefined;
+            content?: string | null | undefined;
+        }, {
+            role?: "user" | "assistant" | null | undefined;
+            content?: string | null | undefined;
+        }>;
+        finish_reason: z.ZodOptional<z.ZodNullable<z.ZodEnum<["stop", "length", "model_length"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        delta: {
+            role?: "user" | "assistant" | null | undefined;
+            content?: string | null | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "model_length" | null | undefined;
+    }, {
+        delta: {
+            role?: "user" | "assistant" | null | undefined;
+            content?: string | null | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "model_length" | null | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    id: string;
+    choices: {
+        delta: {
+            role?: "user" | "assistant" | null | undefined;
+            content?: string | null | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "model_length" | null | undefined;
+    }[];
+    object?: string | undefined;
+    created?: number | undefined;
+}, {
     model: string;
     id: string;
     choices: {
@@ -213,7 +258,7 @@ declare const mistralChatStreamChunkSchema: ZodSchema<{
     object?: string | undefined;
     created?: number | undefined;
 }>;
-export type MistralChatStreamChunk = (typeof mistralChatStreamChunkSchema)["_type"];
+export type MistralChatStreamChunk = z.infer<typeof mistralChatStreamChunkSchema>;
 export type MistralChatResponseFormatType<T> = {
     stream: boolean;
     handler: ResponseHandler<T>;

package/model-provider/mistral/MistralChatModel.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
 import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
@@ -158,7 +158,7 @@ const mistralChatResponseSchema = z.object({
         total_tokens: z.number(),
     }),
 });
-const mistralChatStreamChunkSchema = new ZodSchema(z.object({
+const mistralChatStreamChunkSchema = z.object({
     id: z.string(),
     object: z.string().optional(),
     created: z.number().optional(),
@@ -174,20 +174,20 @@ const mistralChatStreamChunkSchema = new ZodSchema(z.object({
             .nullable()
             .optional(),
     })),
-}));
+});
 export const MistralChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
      */
     json: {
         stream: false,
-        handler: createJsonResponseHandler(mistralChatResponseSchema),
+        handler: createJsonResponseHandler(zodSchema(mistralChatResponseSchema)),
     },
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
     textDeltaIterable: {
         stream: true,
-        handler: createEventSourceResponseHandler(mistralChatStreamChunkSchema),
+        handler: createEventSourceResponseHandler(zodSchema(mistralChatStreamChunkSchema)),
     },
 };

package/model-provider/mistral/MistralError.cjs

@@ -4,14 +4,14 @@ exports.failedMistralCallResponseHandler = void 0;
 const zod_1 = require("zod");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
-const mistralErrorDataSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
+const mistralErrorDataSchema = zod_1.z.object({
     object: zod_1.z.literal("error"),
     message: zod_1.z.string(),
     type: zod_1.z.string(),
     param: zod_1.z.string().nullable(),
     code: zod_1.z.string(),
-}));
+});
 exports.failedMistralCallResponseHandler = (0, postToApi_js_1.createJsonErrorResponseHandler)({
-    errorSchema: mistralErrorDataSchema,
+    errorSchema: (0, ZodSchema_js_1.zodSchema)(mistralErrorDataSchema),
     errorToMessage: (error) => error.message,
 });

package/model-provider/mistral/MistralError.d.ts

@@ -1,13 +1,25 @@
+import { z } from "zod";
 import { ApiCallError } from "../../core/api/ApiCallError.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
-declare const mistralErrorDataSchema: ZodSchema<{
+declare const mistralErrorDataSchema: z.ZodObject<{
+    object: z.ZodLiteral<"error">;
+    message: z.ZodString;
+    type: z.ZodString;
+    param: z.ZodNullable<z.ZodString>;
+    code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    object: "error";
+    message: string;
+    code: string;
+    type: string;
+    param: string | null;
+}, {
     object: "error";
     message: string;
     code: string;
     type: string;
     param: string | null;
 }>;
-export type MistralErrorData = (typeof mistralErrorDataSchema)["_type"];
+export type MistralErrorData = z.infer<typeof mistralErrorDataSchema>;
 export declare const failedMistralCallResponseHandler: ResponseHandler<ApiCallError>;
 export {};

package/model-provider/mistral/MistralError.js

@@ -1,14 +1,14 @@
 import { z } from "zod";
 import { createJsonErrorResponseHandler, } from "../../core/api/postToApi.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
-const mistralErrorDataSchema = new ZodSchema(z.object({
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+const mistralErrorDataSchema = z.object({
     object: z.literal("error"),
     message: z.string(),
     type: z.string(),
     param: z.string().nullable(),
     code: z.string(),
-}));
+});
 export const failedMistralCallResponseHandler = createJsonErrorResponseHandler({
-    errorSchema: mistralErrorDataSchema,
+    errorSchema: zodSchema(mistralErrorDataSchema),
     errorToMessage: (error) => error.message,
 });

package/model-provider/mistral/MistralFacade.cjs

@@ -2,8 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TextEmbedder = exports.ChatTextGenerator = exports.Api = void 0;
 const MistralApiConfiguration_js_1 = require("./MistralApiConfiguration.cjs");
-const MistralTextEmbeddingModel_js_1 = require("./MistralTextEmbeddingModel.cjs");
 const MistralChatModel_js_1 = require("./MistralChatModel.cjs");
+const MistralTextEmbeddingModel_js_1 = require("./MistralTextEmbeddingModel.cjs");
+/**
+ * Creates an API configuration for the Mistral API.
+ * It calls the API at https://api.mistral.ai/v1 and uses the `MISTRAL_API_KEY` env variable by default.
+ */
 function Api(settings) {
     return new MistralApiConfiguration_js_1.MistralApiConfiguration(settings);
 }