modelfusion 0.98.0 → 0.99.0

package/README.md

@@ -211,7 +211,7 @@ const sentiment = await generateStructure(
     .ChatTextGenerator({
       model: "gpt-3.5-turbo",
       temperature: 0,
-      maxCompletionTokens: 50,
+      maxGenerationTokens: 50,
     })
     .asFunctionCallStructureGenerationModel({ fnName: "sentiment" })
     .withInstructionPrompt(),
@@ -541,7 +541,7 @@ const text = await generateText(
   llamacpp
     .TextGenerator({
       contextWindowSize: 4096, // Llama 2 context window size
-      maxCompletionTokens: 1000,
+      maxGenerationTokens: 1000,
     })
     .withTextPromptTemplate(Llama2Prompt.instruction()),
   {
@@ -619,10 +619,10 @@ ModelFusion model functions return rich responses that include the original resp
 
 ```ts
 // access the full response (needs to be typed) and the metadata:
-const { value, response, metadata } = await generateText(
+const { text, response, metadata } = await generateText(
   openai.CompletionTextGenerator({
     model: "gpt-3.5-turbo-instruct",
-    maxCompletionTokens: 1000,
+    maxGenerationTokens: 1000,
     n: 2, // generate 2 completions
   }),
   "Write a short story about a robot learning to love:\n\n",

package/composed-function/summarize/summarizeRecursivelyWithTextGenerationAndTokenSplitting.cjs

@@ -10,7 +10,7 @@ const summarizeRecursively_js_1 = require("./summarizeRecursively.cjs");
  * while leaving enough space for the model to generate text.
  */
 async function summarizeRecursivelyWithTextGenerationAndTokenSplitting({ text, model, prompt, tokenLimit = model.contextWindowSize -
-    (model.settings.maxCompletionTokens ?? model.contextWindowSize / 4), join, }, options) {
+    (model.settings.maxGenerationTokens ?? model.contextWindowSize / 4), join, }, options) {
     const emptyPromptTokens = await model.countPromptTokens(await prompt({ text: "" }));
     return (0, summarizeRecursively_js_1.summarizeRecursively)({
         split: (0, splitRecursively_js_1.splitAtToken)({

package/composed-function/summarize/summarizeRecursivelyWithTextGenerationAndTokenSplitting.js

@@ -7,7 +7,7 @@ import { summarizeRecursively } from "./summarizeRecursively.js";
  * while leaving enough space for the model to generate text.
  */
 export async function summarizeRecursivelyWithTextGenerationAndTokenSplitting({ text, model, prompt, tokenLimit = model.contextWindowSize -
-    (model.settings.maxCompletionTokens ?? model.contextWindowSize / 4), join, }, options) {
+    (model.settings.maxGenerationTokens ?? model.contextWindowSize / 4), join, }, options) {
     const emptyPromptTokens = await model.countPromptTokens(await prompt({ text: "" }));
     return summarizeRecursively({
         split: splitAtToken({

package/model-function/Model.d.ts

@@ -20,11 +20,11 @@ export interface Model<SETTINGS extends ModelSettings> {
      * @example
      * const model = new OpenAICompletionModel({
      *   model: "gpt-3.5-turbo-instruct",
-     *   maxCompletionTokens: 500,
+     *   maxGenerationTokens: 500,
      * });
      *
      * const modelWithMoreTokens = model.withSettings({
-     *   maxCompletionTokens: 1000,
+     *   maxGenerationTokens: 1000,
      * });
      */
     withSettings(additionalSettings: Partial<SETTINGS>): this;

package/model-function/generate-text/PromptTemplateTextGenerationModel.cjs

@@ -40,9 +40,9 @@ class PromptTemplateTextGenerationModel {
         }
         return ((prompt) => originalCountPromptTokens(this.promptTemplate.format(prompt)));
     }
-    doGenerateText(prompt, options) {
+    doGenerateTexts(prompt, options) {
         const mappedPrompt = this.promptTemplate.format(prompt);
-        return this.model.doGenerateText(mappedPrompt, options);
+        return this.model.doGenerateTexts(mappedPrompt, options);
     }
     get settingsForEvent() {
         return this.model.settingsForEvent;

package/model-function/generate-text/PromptTemplateTextGenerationModel.d.ts

@@ -17,9 +17,9 @@ export declare class PromptTemplateTextGenerationModel<PROMPT, MODEL_PROMPT, SET
     get tokenizer(): MODEL["tokenizer"];
     get contextWindowSize(): MODEL["contextWindowSize"];
     get countPromptTokens(): MODEL["countPromptTokens"] extends undefined ? undefined : (prompt: PROMPT) => PromiseLike<number>;
-    doGenerateText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateTexts(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
         response: unknown;
-        text: string;
+        texts: string[];
         usage?: {
             promptTokens: number;
             completionTokens: number;

package/model-function/generate-text/PromptTemplateTextGenerationModel.js

@@ -37,9 +37,9 @@ export class PromptTemplateTextGenerationModel {
         }
         return ((prompt) => originalCountPromptTokens(this.promptTemplate.format(prompt)));
     }
-    doGenerateText(prompt, options) {
+    doGenerateTexts(prompt, options) {
         const mappedPrompt = this.promptTemplate.format(prompt);
-        return this.model.doGenerateText(mappedPrompt, options);
+        return this.model.doGenerateTexts(mappedPrompt, options);
     }
     get settingsForEvent() {
         return this.model.settingsForEvent;

package/model-function/generate-text/TextGenerationModel.d.ts

@@ -5,18 +5,44 @@ import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
 import { TextGenerationPromptTemplate } from "./TextGenerationPromptTemplate.js";
 export interface TextGenerationModelSettings extends ModelSettings {
     /**
-     * Maximum number of tokens to generate.
+     * Specifies the maximum number of tokens (words, punctuation, parts of words) that the model can generate in a single response.
+     * It helps to control the length of the output.
+     *
      * Does nothing if the model does not support this setting.
+     *
+     * Example: `maxGenerationTokens: 1000`
      */
-    maxCompletionTokens?: number | undefined;
+    maxGenerationTokens?: number | undefined;
     /**
-     * Stop sequences to use. Stop sequences are not included in the generated text.
+     * Stop sequences to use.
+     * Stop sequences are an array of strings or a single string that the model will recognize as end-of-text indicators.
+     * The model stops generating more content when it encounters any of these strings.
+     * This is particularly useful in scripted or formatted text generation, where a specific end point is required.
+     * Stop sequences not included in the generated text.
+     *
      * Does nothing if the model does not support this setting.
+     *
+     * Example: `stopSequences: ['\n', 'END']`
      */
     stopSequences?: string[] | undefined;
+    /**
+     * Number of texts to generate.
+     *
+     * Specifies the number of responses or completions the model should generate for a given prompt.
+     * This is useful when you need multiple different outputs or ideas for a single prompt.
+     * The model will generate 'n' distinct responses, each based on the same initial prompt.
+     * In a streaming model this will result in both responses streamed back in real time.
+     *
+     * Does nothing if the model does not support this setting.
+     *
+     * Example: `numberOfGenerations: 3` // The model will produce 3 different responses.
+     */
+    numberOfGenerations?: number;
     /**
      * When true, the leading and trailing white space and line terminator characters
      * are removed from the generated text.
+     *
+     * Default: true.
      */
     trimWhitespace?: boolean;
 }
@@ -34,9 +60,9 @@ export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationMode
      * Optional. Implement if you have a tokenizer and want to count the number of tokens in a prompt.
      */
     readonly countPromptTokens: ((prompt: PROMPT) => PromiseLike<number>) | undefined;
-    doGenerateText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateTexts(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
         response: unknown;
-        text: string;
+        texts: string[];
         usage?: {
             promptTokens: number;
             completionTokens: number;

package/model-function/generate-text/generateText.cjs

@@ -9,21 +9,27 @@ async function generateText(model, prompt, options) {
         model,
         options,
         generateResponse: async (options) => {
-            const result = await model.doGenerateText(prompt, options);
+            const result = await model.doGenerateTexts(prompt, options);
             const shouldTrimWhitespace = model.settings.trimWhitespace ?? true;
+            const texts = shouldTrimWhitespace
+                ? result.texts.map((text) => text.trim())
+                : result.texts;
             return {
                 response: result.response,
-                extractedValue: shouldTrimWhitespace ? result.text.trim() : result.text,
+                extractedValue: texts,
                 usage: result.usage,
             };
         },
     });
+    const texts = fullResponse.value;
+    const text = texts[0];
     return options?.fullResponse
         ? {
-            text: fullResponse.value,
+            text,
+            texts,
             response: fullResponse.response,
             metadata: fullResponse.metadata,
         }
-        : fullResponse.value;
+        : text;
 }
 exports.generateText = generateText;

package/model-function/generate-text/generateText.d.ts

@@ -29,6 +29,7 @@ export declare function generateText<PROMPT>(model: TextGenerationModel<PROMPT,
     fullResponse: true;
 }): Promise<{
     text: string;
+    texts: string[];
     response: unknown;
     metadata: ModelCallMetadata;
 }>;

package/model-function/generate-text/generateText.js

@@ -6,20 +6,26 @@ export async function generateText(model, prompt, options) {
         model,
         options,
         generateResponse: async (options) => {
-            const result = await model.doGenerateText(prompt, options);
+            const result = await model.doGenerateTexts(prompt, options);
             const shouldTrimWhitespace = model.settings.trimWhitespace ?? true;
+            const texts = shouldTrimWhitespace
+                ? result.texts.map((text) => text.trim())
+                : result.texts;
             return {
                 response: result.response,
-                extractedValue: shouldTrimWhitespace ? result.text.trim() : result.text,
+                extractedValue: texts,
                 usage: result.usage,
             };
         },
     });
+    const texts = fullResponse.value;
+    const text = texts[0];
     return options?.fullResponse
         ? {
-            text: fullResponse.value,
+            text,
+            texts,
             response: fullResponse.response,
             metadata: fullResponse.metadata,
         }
-        : fullResponse.value;
+        : text;
 }

package/model-function/generate-text/prompt-template/trimChatPrompt.cjs

@@ -13,7 +13,7 @@ const ChatPrompt_js_1 = require("./ChatPrompt.cjs");
  * @see https://modelfusion.dev/guide/function/generate-text#limiting-the-chat-length
  */
 async function trimChatPrompt({ prompt, model, tokenLimit = model.contextWindowSize -
-    (model.settings.maxCompletionTokens ?? model.contextWindowSize / 4), }) {
+    (model.settings.maxGenerationTokens ?? model.contextWindowSize / 4), }) {
     (0, ChatPrompt_js_1.validateChatPrompt)(prompt);
     let minimalPrompt = {
         system: prompt.system,

package/model-function/generate-text/prompt-template/trimChatPrompt.js

@@ -10,7 +10,7 @@ import { validateChatPrompt } from "./ChatPrompt.js";
  * @see https://modelfusion.dev/guide/function/generate-text#limiting-the-chat-length
  */
 export async function trimChatPrompt({ prompt, model, tokenLimit = model.contextWindowSize -
-    (model.settings.maxCompletionTokens ?? model.contextWindowSize / 4), }) {
+    (model.settings.maxGenerationTokens ?? model.contextWindowSize / 4), }) {
     validateChatPrompt(prompt);
     let minimalPrompt = {
         system: prompt.system,

package/model-provider/anthropic/AnthropicTextGenerationModel.cjs

@@ -69,22 +69,38 @@ class AnthropicTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
+        const api = this.settings.api ?? new AnthropicApiConfiguration_js_1.AnthropicApiConfiguration();
+        const responseFormat = options.responseFormat;
+        const abortSignal = options.run?.abortSignal;
+        const userId = this.settings.userId;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callAnthropicTextGenerationAPI({
-                ...this.settings,
-                stopSequences: this.settings.stopSequences,
-                maxTokens: this.settings.maxCompletionTokens,
-                abortSignal: options.run?.abortSignal,
-                responseFormat: options.responseFormat,
-                prompt,
-            }),
+            call: async () => {
+                return (0, postToApi_js_1.postJsonToApi)({
+                    url: api.assembleUrl(`/complete`),
+                    headers: api.headers,
+                    body: {
+                        model: this.settings.model,
+                        prompt,
+                        stream: responseFormat.stream,
+                        max_tokens_to_sample: this.settings.maxGenerationTokens,
+                        temperature: this.settings.temperature,
+                        top_k: this.settings.topK,
+                        top_p: this.settings.topP,
+                        stop_sequences: this.settings.stopSequences,
+                        metadata: userId != null ? { user_id: userId } : undefined,
+                    },
+                    failedResponseHandler: AnthropicError_js_1.failedAnthropicCallResponseHandler,
+                    successfulResponseHandler: responseFormat.handler,
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "stopSequences",
             "temperature",
             "topK",
@@ -93,14 +109,14 @@ class AnthropicTextGenerationModel 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.AnthropicTextGenerationResponseFormat.json,
         });
         return {
             response,
-            text: response.completion,
+            texts: [response.completion],
         };
     }
     doStreamText(prompt, options) {
@@ -148,26 +164,6 @@ const anthropicTextGenerationResponseSchema = zod_1.z.object({
     stop_reason: zod_1.z.string(),
     model: zod_1.z.string(),
 });
-async function callAnthropicTextGenerationAPI({ api = new AnthropicApiConfiguration_js_1.AnthropicApiConfiguration(), abortSignal, responseFormat, model, prompt, maxTokens, stopSequences, temperature, topK, topP, userId, }) {
-    return (0, postToApi_js_1.postJsonToApi)({
-        url: api.assembleUrl(`/complete`),
-        headers: api.headers,
-        body: {
-            model,
-            prompt,
-            stream: responseFormat.stream,
-            max_tokens_to_sample: maxTokens,
-            temperature,
-            top_k: topK,
-            top_p: topP,
-            stop_sequences: stopSequences,
-            metadata: userId != null ? { user_id: userId } : undefined,
-        },
-        failedResponseHandler: AnthropicError_js_1.failedAnthropicCallResponseHandler,
-        successfulResponseHandler: responseFormat.handler,
-        abortSignal,
-    });
-}
 const anthropicTextStreamingResponseSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
     completion: zod_1.z.string(),
     stop_reason: zod_1.z.string().nullable(),

package/model-provider/anthropic/AnthropicTextGenerationModel.d.ts

@@ -49,13 +49,13 @@ export declare class AnthropicTextGenerationModel extends AbstractModel<Anthropi
         responseFormat: AnthropicTextGenerationResponseFormatType<RESPONSE>;
     } & FunctionOptions): Promise<RESPONSE>;
     get settingsForEvent(): Partial<AnthropicTextGenerationModelSettings>;
-    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: string, options?: FunctionOptions): Promise<{
         response: {
             model: string;
             completion: string;
             stop_reason: string;
         };
-        text: string;
+        texts: string[];
     }>;
     doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
     /**

package/model-provider/anthropic/AnthropicTextGenerationModel.js

@@ -66,22 +66,38 @@ export class AnthropicTextGenerationModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
+        const api = this.settings.api ?? new AnthropicApiConfiguration();
+        const responseFormat = options.responseFormat;
+        const abortSignal = options.run?.abortSignal;
+        const userId = this.settings.userId;
         return callWithRetryAndThrottle({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callAnthropicTextGenerationAPI({
-                ...this.settings,
-                stopSequences: this.settings.stopSequences,
-                maxTokens: this.settings.maxCompletionTokens,
-                abortSignal: options.run?.abortSignal,
-                responseFormat: options.responseFormat,
-                prompt,
-            }),
+            call: async () => {
+                return postJsonToApi({
+                    url: api.assembleUrl(`/complete`),
+                    headers: api.headers,
+                    body: {
+                        model: this.settings.model,
+                        prompt,
+                        stream: responseFormat.stream,
+                        max_tokens_to_sample: this.settings.maxGenerationTokens,
+                        temperature: this.settings.temperature,
+                        top_k: this.settings.topK,
+                        top_p: this.settings.topP,
+                        stop_sequences: this.settings.stopSequences,
+                        metadata: userId != null ? { user_id: userId } : undefined,
+                    },
+                    failedResponseHandler: failedAnthropicCallResponseHandler,
+                    successfulResponseHandler: responseFormat.handler,
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "stopSequences",
             "temperature",
             "topK",
@@ -90,14 +106,14 @@ export class AnthropicTextGenerationModel 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: AnthropicTextGenerationResponseFormat.json,
         });
         return {
             response,
-            text: response.completion,
+            texts: [response.completion],
         };
     }
     doStreamText(prompt, options) {
@@ -144,26 +160,6 @@ const anthropicTextGenerationResponseSchema = z.object({
     stop_reason: z.string(),
     model: z.string(),
 });
-async function callAnthropicTextGenerationAPI({ api = new AnthropicApiConfiguration(), abortSignal, responseFormat, model, prompt, maxTokens, stopSequences, temperature, topK, topP, userId, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/complete`),
-        headers: api.headers,
-        body: {
-            model,
-            prompt,
-            stream: responseFormat.stream,
-            max_tokens_to_sample: maxTokens,
-            temperature,
-            top_k: topK,
-            top_p: topP,
-            stop_sequences: stopSequences,
-            metadata: userId != null ? { user_id: userId } : undefined,
-        },
-        failedResponseHandler: failedAnthropicCallResponseHandler,
-        successfulResponseHandler: responseFormat.handler,
-        abortSignal,
-    });
-}
 const anthropicTextStreamingResponseSchema = new ZodSchema(z.object({
     completion: z.string(),
     stop_reason: z.string().nullable(),

package/model-provider/cohere/CohereFacade.cjs

@@ -13,7 +13,7 @@ const CohereTokenizer_js_1 = require("./CohereTokenizer.cjs");
  * const model = cohere.TextGenerator({
  *   model: "command-nightly",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText(

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

@@ -10,7 +10,7 @@ import { CohereTokenizer, CohereTokenizerSettings } from "./CohereTokenizer.js";
  * const model = cohere.TextGenerator({
  *   model: "command-nightly",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText(

package/model-provider/cohere/CohereFacade.js

@@ -10,7 +10,7 @@ import { CohereTokenizer } from "./CohereTokenizer.js";
  * const model = cohere.TextGenerator({
  *   model: "command-nightly",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText(

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

@@ -74,6 +74,7 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
     get settingsForEvent(): Partial<CohereTextEmbeddingModelSettings>;
     doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
         response: {
+            texts: string[];
             embeddings: number[][];
             id: string;
             meta: {
@@ -81,7 +82,6 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
                     version: string;
                 };
             };
-            texts: string[];
         };
         embeddings: number[][];
     }>;
@@ -109,6 +109,7 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     }>;
 }, "strip", z.ZodTypeAny, {
+    texts: string[];
     embeddings: number[][];
     id: string;
     meta: {
@@ -116,8 +117,8 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
             version: string;
         };
     };
-    texts: string[];
 }, {
+    texts: string[];
     embeddings: number[][];
     id: string;
     meta: {
@@ -125,7 +126,6 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
             version: string;
         };
     };
-    texts: string[];
 }>;
 export type CohereTextEmbeddingResponse = z.infer<typeof cohereTextEmbeddingResponseSchema>;
 export {};

package/model-provider/cohere/CohereTextGenerationModel.cjs

@@ -37,7 +37,7 @@ exports.COHERE_TEXT_GENERATION_MODELS = {
  * const model = new CohereTextGenerationModel({
  *   model: "command-nightly",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText(
@@ -80,28 +80,45 @@ class CohereTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
     }
     async callAPI(prompt, options) {
+        const api = this.settings.api ?? new CohereApiConfiguration_js_1.CohereApiConfiguration();
+        const responseFormat = options.responseFormat;
+        const abortSignal = options.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.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 (0, postToApi_js_1.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: CohereError_js_1.failedCohereCallResponseHandler,
+                    successfulResponseHandler: responseFormat.handler,
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "stopSequences",
-            "numGenerations",
+            "numberOfGenerations",
             "temperature",
             "k",
             "p",
@@ -114,14 +131,14 @@ class CohereTextGenerationModel 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.CohereTextGenerationResponseFormat.json,
         });
         return {
             response,
-            text: response.generations[0].text,
+            texts: response.generations.map((generation) => generation.text),
         };
     }
     doStreamText(prompt, options) {
@@ -177,32 +194,6 @@ const cohereTextGenerationResponseSchema = zod_1.z.object({
     })
         .optional(),
 });
-async function callCohereTextGenerationAPI({ api = new CohereApiConfiguration_js_1.CohereApiConfiguration(), abortSignal, responseFormat, model, prompt, numGenerations, maxTokens, temperature, k, p, frequencyPenalty, presencePenalty, endSequences, stopSequences, returnLikelihoods, logitBias, truncate, }) {
-    return (0, postToApi_js_1.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: CohereError_js_1.failedCohereCallResponseHandler,
-        successfulResponseHandler: responseFormat.handler,
-        abortSignal,
-    });
-}
 const cohereTextStreamingResponseSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.discriminatedUnion("is_finished", [
     zod_1.z.object({
         text: zod_1.z.string(),