modelfusion 0.97.0 → 0.99.0

package/model-provider/cohere/CohereTextGenerationModel.d.ts

@@ -26,7 +26,6 @@ export type CohereTextGenerationModelType = keyof typeof COHERE_TEXT_GENERATION_
 export interface CohereTextGenerationModelSettings extends TextGenerationModelSettings {
     api?: ApiConfiguration;
     model: CohereTextGenerationModelType;
-    numGenerations?: number;
     temperature?: number;
     k?: number;
     p?: number;
@@ -46,7 +45,7 @@ export interface CohereTextGenerationModelSettings extends TextGenerationModelSe
  * const model = new CohereTextGenerationModel({
  *   model: "command-nightly",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText(
@@ -65,7 +64,7 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
         responseFormat: CohereTextGenerationResponseFormatType<RESPONSE>;
     } & FunctionOptions): Promise<RESPONSE>;
     get settingsForEvent(): Partial<CohereTextGenerationModelSettings>;
-    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: string, options?: FunctionOptions): Promise<{
         response: {
             prompt: string;
             id: string;
@@ -80,7 +79,7 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
                 };
             } | undefined;
         };
-        text: string;
+        texts: string[];
     }>;
     doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
     extractTextDelta(fullDelta: CohereTextGenerationDelta): string | undefined;

package/model-provider/cohere/CohereTextGenerationModel.js

@@ -34,7 +34,7 @@ export const COHERE_TEXT_GENERATION_MODELS = {
  * const model = new CohereTextGenerationModel({
  *   model: "command-nightly",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText(
@@ -77,28 +77,45 @@ export class CohereTextGenerationModel extends AbstractModel {
         return countTokens(this.tokenizer, input);
     }
     async callAPI(prompt, options) {
+        const api = this.settings.api ?? new CohereApiConfiguration();
+        const responseFormat = options.responseFormat;
+        const abortSignal = options.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callCohereTextGenerationAPI({
-                ...this.settings,
-                // use endSequences instead of stopSequences
-                // to exclude stop tokens from the generated text
-                endSequences: this.settings.stopSequences,
-                maxTokens: this.settings.maxCompletionTokens,
-                // mapped name because of conflict with stopSequences:
-                stopSequences: this.settings.cohereStopSequences,
-                abortSignal: options.run?.abortSignal,
-                responseFormat: options.responseFormat,
-                prompt,
-            }),
+            call: async () => {
+                return postJsonToApi({
+                    url: api.assembleUrl(`/generate`),
+                    headers: api.headers,
+                    body: {
+                        stream: responseFormat.stream,
+                        model: this.settings.model,
+                        prompt,
+                        num_generations: this.settings.numberOfGenerations,
+                        max_tokens: this.settings.maxGenerationTokens,
+                        temperature: this.settings.temperature,
+                        k: this.settings.k,
+                        p: this.settings.p,
+                        frequency_penalty: this.settings.frequencyPenalty,
+                        presence_penalty: this.settings.presencePenalty,
+                        end_sequences: this.settings.stopSequences,
+                        stop_sequences: this.settings.cohereStopSequences,
+                        return_likelihoods: this.settings.returnLikelihoods,
+                        logit_bias: this.settings.logitBias,
+                        truncate: this.settings.truncate,
+                    },
+                    failedResponseHandler: failedCohereCallResponseHandler,
+                    successfulResponseHandler: responseFormat.handler,
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "stopSequences",
-            "numGenerations",
+            "numberOfGenerations",
             "temperature",
             "k",
             "p",
@@ -111,14 +128,14 @@ export class CohereTextGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: CohereTextGenerationResponseFormat.json,
         });
         return {
             response,
-            text: response.generations[0].text,
+            texts: response.generations.map((generation) => generation.text),
         };
     }
     doStreamText(prompt, options) {
@@ -173,32 +190,6 @@ const cohereTextGenerationResponseSchema = z.object({
     })
         .optional(),
 });
-async function callCohereTextGenerationAPI({ api = new CohereApiConfiguration(), abortSignal, responseFormat, model, prompt, numGenerations, maxTokens, temperature, k, p, frequencyPenalty, presencePenalty, endSequences, stopSequences, returnLikelihoods, logitBias, truncate, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/generate`),
-        headers: api.headers,
-        body: {
-            stream: responseFormat.stream,
-            model,
-            prompt,
-            num_generations: numGenerations,
-            max_tokens: maxTokens,
-            temperature,
-            k,
-            p,
-            frequency_penalty: frequencyPenalty,
-            presence_penalty: presencePenalty,
-            end_sequences: endSequences,
-            stop_sequences: stopSequences,
-            return_likelihoods: returnLikelihoods,
-            logit_bias: logitBias,
-            truncate,
-        },
-        failedResponseHandler: failedCohereCallResponseHandler,
-        successfulResponseHandler: responseFormat.handler,
-        abortSignal,
-    });
-}
 const cohereTextStreamingResponseSchema = new ZodSchema(z.discriminatedUnion("is_finished", [
     z.object({
         text: z.string(),

package/model-provider/huggingface/HuggingFaceFacade.cjs

@@ -12,7 +12,7 @@ const HuggingFaceTextGenerationModel_js_1 = require("./HuggingFaceTextGeneration
  * const model = huggingface.TextGenerator({
  *   model: "tiiuae/falcon-7b",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
  * });
  *

package/model-provider/huggingface/HuggingFaceFacade.d.ts

@@ -9,7 +9,7 @@ import { HuggingFaceTextGenerationModel, HuggingFaceTextGenerationModelSettings
  * const model = huggingface.TextGenerator({
  *   model: "tiiuae/falcon-7b",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
  * });
  *

package/model-provider/huggingface/HuggingFaceFacade.js

@@ -9,7 +9,7 @@ import { HuggingFaceTextGenerationModel, } from "./HuggingFaceTextGenerationMode
  * const model = huggingface.TextGenerator({
  *   model: "tiiuae/falcon-7b",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
  * });
  *

package/model-provider/huggingface/HuggingFaceTextGenerationModel.cjs

@@ -17,7 +17,7 @@ const HuggingFaceError_js_1 = require("./HuggingFaceError.cjs");
  * const model = new HuggingFaceTextGenerationModel({
  *   model: "tiiuae/falcon-7b",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
  * });
  *
@@ -58,41 +58,57 @@ class HuggingFaceTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
+        const api = this.settings.api ?? new HuggingFaceApiConfiguration_js_1.HuggingFaceApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callHuggingFaceTextGenerationAPI({
-                options: {
-                    useCache: true,
-                    waitForModel: true,
-                },
-                ...this.settings,
-                maxNewTokens: this.settings.maxCompletionTokens,
-                abortSignal: options?.run?.abortSignal,
-                inputs: prompt,
-            }),
+            call: async () => {
+                return (0, postToApi_js_1.postJsonToApi)({
+                    url: api.assembleUrl(`/${this.settings.model}`),
+                    headers: api.headers,
+                    body: {
+                        inputs: prompt,
+                        top_k: this.settings.topK,
+                        top_p: this.settings.topP,
+                        temperature: this.settings.temperature,
+                        repetition_penalty: this.settings.repetitionPenalty,
+                        max_new_tokens: this.settings.maxGenerationTokens,
+                        max_time: this.settings.maxTime,
+                        num_return_sequences: this.settings.numberOfGenerations,
+                        do_sample: this.settings.doSample,
+                        options: {
+                            use_cache: true,
+                            wait_for_model: true,
+                        },
+                    },
+                    failedResponseHandler: HuggingFaceError_js_1.failedHuggingFaceCallResponseHandler,
+                    successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(huggingFaceTextGenerationResponseSchema),
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
             "stopSequences",
-            "maxCompletionTokens",
+            "maxGenerationTokens",
+            "numberOfGenerations",
             "topK",
             "topP",
             "temperature",
             "repetitionPenalty",
             "maxTime",
-            "numReturnSequences",
             "doSample",
             "options",
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, options);
         return {
             response,
-            text: response[0].generated_text,
+            texts: response.map((response) => response.generated_text),
         };
     }
     withPromptTemplate(promptTemplate) {
@@ -109,29 +125,3 @@ exports.HuggingFaceTextGenerationModel = HuggingFaceTextGenerationModel;
 const huggingFaceTextGenerationResponseSchema = zod_1.z.array(zod_1.z.object({
     generated_text: zod_1.z.string(),
 }));
-async function callHuggingFaceTextGenerationAPI({ api = new HuggingFaceApiConfiguration_js_1.HuggingFaceApiConfiguration(), abortSignal, model, inputs, topK, topP, temperature, repetitionPenalty, maxNewTokens, maxTime, numReturnSequences, doSample, options, }) {
-    return (0, postToApi_js_1.postJsonToApi)({
-        url: api.assembleUrl(`/${model}`),
-        headers: api.headers,
-        body: {
-            inputs,
-            top_k: topK,
-            top_p: topP,
-            temperature,
-            repetition_penalty: repetitionPenalty,
-            max_new_tokens: maxNewTokens,
-            max_time: maxTime,
-            num_return_sequences: numReturnSequences,
-            do_sample: doSample,
-            options: options
-                ? {
-                    use_cache: options?.useCache,
-                    wait_for_model: options?.waitForModel,
-                }
-                : undefined,
-        },
-        failedResponseHandler: HuggingFaceError_js_1.failedHuggingFaceCallResponseHandler,
-        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(huggingFaceTextGenerationResponseSchema),
-        abortSignal,
-    });
-}

package/model-provider/huggingface/HuggingFaceTextGenerationModel.d.ts

@@ -13,7 +13,6 @@ export interface HuggingFaceTextGenerationModelSettings extends TextGenerationMo
     temperature?: number;
     repetitionPenalty?: number;
     maxTime?: number;
-    numReturnSequences?: number;
     doSample?: boolean;
     options?: {
         useCache?: boolean;
@@ -29,7 +28,7 @@ export interface HuggingFaceTextGenerationModelSettings extends TextGenerationMo
  * const model = new HuggingFaceTextGenerationModel({
  *   model: "tiiuae/falcon-7b",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
  * });
  *
@@ -47,11 +46,11 @@ export declare class HuggingFaceTextGenerationModel extends AbstractModel<Huggin
     readonly countPromptTokens: undefined;
     callAPI(prompt: string, options?: FunctionOptions): Promise<HuggingFaceTextGenerationResponse>;
     get settingsForEvent(): Partial<HuggingFaceTextGenerationModelSettings>;
-    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: string, options?: FunctionOptions): Promise<{
         response: {
             generated_text: string;
         }[];
-        text: string;
+        texts: string[];
     }>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, string>): PromptTemplateTextGenerationModel<INPUT_PROMPT, string, HuggingFaceTextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<HuggingFaceTextGenerationModelSettings>): this;

package/model-provider/huggingface/HuggingFaceTextGenerationModel.js

@@ -14,7 +14,7 @@ import { failedHuggingFaceCallResponseHandler } from "./HuggingFaceError.js";
  * const model = new HuggingFaceTextGenerationModel({
  *   model: "tiiuae/falcon-7b",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
  * });
  *
@@ -55,41 +55,57 @@ export class HuggingFaceTextGenerationModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
+        const api = this.settings.api ?? new HuggingFaceApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callHuggingFaceTextGenerationAPI({
-                options: {
-                    useCache: true,
-                    waitForModel: true,
-                },
-                ...this.settings,
-                maxNewTokens: this.settings.maxCompletionTokens,
-                abortSignal: options?.run?.abortSignal,
-                inputs: prompt,
-            }),
+            call: async () => {
+                return postJsonToApi({
+                    url: api.assembleUrl(`/${this.settings.model}`),
+                    headers: api.headers,
+                    body: {
+                        inputs: prompt,
+                        top_k: this.settings.topK,
+                        top_p: this.settings.topP,
+                        temperature: this.settings.temperature,
+                        repetition_penalty: this.settings.repetitionPenalty,
+                        max_new_tokens: this.settings.maxGenerationTokens,
+                        max_time: this.settings.maxTime,
+                        num_return_sequences: this.settings.numberOfGenerations,
+                        do_sample: this.settings.doSample,
+                        options: {
+                            use_cache: true,
+                            wait_for_model: true,
+                        },
+                    },
+                    failedResponseHandler: failedHuggingFaceCallResponseHandler,
+                    successfulResponseHandler: createJsonResponseHandler(huggingFaceTextGenerationResponseSchema),
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
             "stopSequences",
-            "maxCompletionTokens",
+            "maxGenerationTokens",
+            "numberOfGenerations",
             "topK",
             "topP",
             "temperature",
             "repetitionPenalty",
             "maxTime",
-            "numReturnSequences",
             "doSample",
             "options",
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, options);
         return {
             response,
-            text: response[0].generated_text,
+            texts: response.map((response) => response.generated_text),
         };
     }
     withPromptTemplate(promptTemplate) {
@@ -105,29 +121,3 @@ export class HuggingFaceTextGenerationModel extends AbstractModel {
 const huggingFaceTextGenerationResponseSchema = z.array(z.object({
     generated_text: z.string(),
 }));
-async function callHuggingFaceTextGenerationAPI({ api = new HuggingFaceApiConfiguration(), abortSignal, model, inputs, topK, topP, temperature, repetitionPenalty, maxNewTokens, maxTime, numReturnSequences, doSample, options, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/${model}`),
-        headers: api.headers,
-        body: {
-            inputs,
-            top_k: topK,
-            top_p: topP,
-            temperature,
-            repetition_penalty: repetitionPenalty,
-            max_new_tokens: maxNewTokens,
-            max_time: maxTime,
-            num_return_sequences: numReturnSequences,
-            do_sample: doSample,
-            options: options
-                ? {
-                    use_cache: options?.useCache,
-                    wait_for_model: options?.waitForModel,
-                }
-                : undefined,
-        },
-        failedResponseHandler: failedHuggingFaceCallResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler(huggingFaceTextGenerationResponseSchema),
-        abortSignal,
-    });
-}

package/model-provider/llamacpp/LlamaCppTextGenerationModel.cjs

@@ -43,7 +43,7 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callLlamaCppTextGenerationAPI({
                 ...this.settings,
                 // mapping
-                nPredict: this.settings.maxCompletionTokens,
+                nPredict: this.settings.maxGenerationTokens,
                 stop: this.settings.stopSequences,
                 // other
                 abortSignal: options.run?.abortSignal,
@@ -54,7 +54,7 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.AbstractModel {
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "stopSequences",
             "contextWindowSize",
             "cachePrompt",
@@ -80,14 +80,14 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         const tokens = await this.tokenizer.tokenize(prompt.text);
         return tokens.length;
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: exports.LlamaCppTextGenerationResponseFormat.json,
         });
         return {
             response,
-            text: response.content,
+            texts: [response.content],
             usage: {
                 promptTokens: response.tokens_evaluated,
                 completionTokens: response.tokens_predicted,

package/model-provider/llamacpp/LlamaCppTextGenerationModel.d.ts

@@ -56,7 +56,7 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
     } & FunctionOptions): Promise<RESPONSE>;
     get settingsForEvent(): Partial<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>;
     countPromptTokens(prompt: LlamaCppTextGenerationPrompt): Promise<number>;
-    doGenerateText(prompt: LlamaCppTextGenerationPrompt, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: LlamaCppTextGenerationPrompt, options?: FunctionOptions): Promise<{
         response: {
             model: string;
             prompt: string;
@@ -106,7 +106,7 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
             tokens_predicted: number;
             truncated: boolean;
         };
-        text: string;
+        texts: string[];
         usage: {
             promptTokens: number;
             completionTokens: number;

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -40,7 +40,7 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
             call: async () => callLlamaCppTextGenerationAPI({
                 ...this.settings,
                 // mapping
-                nPredict: this.settings.maxCompletionTokens,
+                nPredict: this.settings.maxGenerationTokens,
                 stop: this.settings.stopSequences,
                 // other
                 abortSignal: options.run?.abortSignal,
@@ -51,7 +51,7 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "stopSequences",
             "contextWindowSize",
             "cachePrompt",
@@ -77,14 +77,14 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
         const tokens = await this.tokenizer.tokenize(prompt.text);
         return tokens.length;
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: LlamaCppTextGenerationResponseFormat.json,
         });
         return {
             response,
-            text: response.content,
+            texts: [response.content],
             usage: {
                 promptTokens: response.tokens_evaluated,
                 completionTokens: response.tokens_predicted,

package/model-provider/mistral/MistralTextGenerationModel.cjs

@@ -45,7 +45,7 @@ class MistralTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
-        const { model, temperature, topP, safeMode, randomSeed, maxCompletionTokens, } = this.settings;
+        const { model, temperature, topP, safeMode, randomSeed, maxGenerationTokens, } = this.settings;
         const api = this.settings.api ?? new MistralApiConfiguration_js_1.MistralApiConfiguration();
         const abortSignal = options.run?.abortSignal;
         const stream = options.responseFormat.stream;
@@ -62,7 +62,7 @@ class MistralTextGenerationModel extends AbstractModel_js_1.AbstractModel {
                     model,
                     temperature,
                     top_p: topP,
-                    max_tokens: maxCompletionTokens,
+                    max_tokens: maxGenerationTokens,
                     safe_mode: safeMode,
                     random_seed: randomSeed,
                 },
@@ -74,7 +74,7 @@ class MistralTextGenerationModel extends AbstractModel_js_1.AbstractModel {
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "temperature",
             "topP",
             "safeMode",
@@ -82,14 +82,14 @@ class MistralTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: exports.MistralTextGenerationResponseFormat.json,
         });
         return {
             response,
-            text: response.choices[0].message.content,
+            texts: response.choices.map((choice) => choice.message.content),
         };
     }
     doStreamText(prompt, options) {

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

@@ -57,7 +57,7 @@ export declare class MistralTextGenerationModel extends AbstractModel<MistralTex
         responseFormat: MistralTextGenerationResponseFormatType<RESULT>;
     } & FunctionOptions): Promise<RESULT>;
     get settingsForEvent(): Partial<MistralTextGenerationModelSettings>;
-    doGenerateText(prompt: MistralTextGenerationPrompt, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: MistralTextGenerationPrompt, options?: FunctionOptions): Promise<{
         response: {
             object: string;
             usage: {
@@ -77,7 +77,7 @@ export declare class MistralTextGenerationModel extends AbstractModel<MistralTex
                 index: number;
             }[];
         };
-        text: string;
+        texts: string[];
     }>;
     doStreamText(prompt: MistralTextGenerationPrompt, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
     /**

package/model-provider/mistral/MistralTextGenerationModel.js

@@ -42,7 +42,7 @@ export class MistralTextGenerationModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
-        const { model, temperature, topP, safeMode, randomSeed, maxCompletionTokens, } = this.settings;
+        const { model, temperature, topP, safeMode, randomSeed, maxGenerationTokens, } = this.settings;
         const api = this.settings.api ?? new MistralApiConfiguration();
         const abortSignal = options.run?.abortSignal;
         const stream = options.responseFormat.stream;
@@ -59,7 +59,7 @@ export class MistralTextGenerationModel extends AbstractModel {
                     model,
                     temperature,
                     top_p: topP,
-                    max_tokens: maxCompletionTokens,
+                    max_tokens: maxGenerationTokens,
                     safe_mode: safeMode,
                     random_seed: randomSeed,
                 },
@@ -71,7 +71,7 @@ export class MistralTextGenerationModel extends AbstractModel {
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "temperature",
             "topP",
             "safeMode",
@@ -79,14 +79,14 @@ export class MistralTextGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: MistralTextGenerationResponseFormat.json,
         });
         return {
             response,
-            text: response.choices[0].message.content,
+            texts: response.choices.map((choice) => choice.message.content),
         };
     }
     doStreamText(prompt, options) {