modelfusion 0.97.0 → 0.99.0

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,15 +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,
             };
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    const texts = fullResponse.value;
+    const text = texts[0];
+    return options?.fullResponse
+        ? {
+            text,
+            texts,
+            response: fullResponse.response,
+            metadata: fullResponse.metadata,
+        }
+        : text;
 }
 exports.generateText = generateText;

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

@@ -23,12 +23,13 @@ import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerati
  * @returns {Promise<string>} - A promise that resolves to the generated text.
  */
 export declare function generateText<PROMPT>(model: TextGenerationModel<PROMPT, TextGenerationModelSettings>, prompt: PROMPT, options?: FunctionOptions & {
-    returnType?: "text";
+    fullResponse?: false;
 }): Promise<string>;
 export declare function generateText<PROMPT>(model: TextGenerationModel<PROMPT, TextGenerationModelSettings>, prompt: PROMPT, options: FunctionOptions & {
-    returnType: "full";
+    fullResponse: true;
 }): Promise<{
-    value: string;
+    text: string;
+    texts: string[];
     response: unknown;
     metadata: ModelCallMetadata;
 }>;

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

@@ -6,14 +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,
             };
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    const texts = fullResponse.value;
+    const text = texts[0];
+    return options?.fullResponse
+        ? {
+            text,
+            texts,
+            response: fullResponse.response,
+            metadata: fullResponse.metadata,
+        }
+        : 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-function/generate-text/streamText.cjs

@@ -45,6 +45,11 @@ async function streamText(model, prompt, options) {
             value: accumulatedText,
         }),
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse
+        ? {
+            textStream: fullResponse.value,
+            metadata: fullResponse.metadata,
+        }
+        : fullResponse.value;
 }
 exports.streamText = streamText;

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

@@ -27,11 +27,11 @@ import { TextStreamingModel } from "./TextGenerationModel.js";
  * @returns {AsyncIterableResultPromise<string>} An async iterable promise that yields the generated text.
  */
 export declare function streamText<PROMPT>(model: TextStreamingModel<PROMPT>, prompt: PROMPT, options?: FunctionOptions & {
-    returnType?: "text-stream";
+    fullResponse?: false;
 }): Promise<AsyncIterable<string>>;
 export declare function streamText<PROMPT>(model: TextStreamingModel<PROMPT>, prompt: PROMPT, options: FunctionOptions & {
-    returnType: "full";
+    fullResponse: true;
 }): Promise<{
-    value: AsyncIterable<string>;
+    textStream: AsyncIterable<string>;
     metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
 }>;

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

@@ -42,5 +42,10 @@ export async function streamText(model, prompt, options) {
             value: accumulatedText,
         }),
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse
+        ? {
+            textStream: fullResponse.value,
+            metadata: fullResponse.metadata,
+        }
+        : fullResponse.value;
 }

package/model-function/generate-transcription/generateTranscription.cjs

@@ -16,6 +16,6 @@ async function generateTranscription(model, data, options) {
             };
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse ? fullResponse : fullResponse.value;
 }
 exports.generateTranscription = generateTranscription;

package/model-function/generate-transcription/generateTranscription.d.ts

@@ -21,10 +21,10 @@ import { TranscriptionModel, TranscriptionModelSettings } from "./TranscriptionM
  * @returns {Promise<string>} A promise that resolves to the transcribed text.
  */
 export declare function generateTranscription<DATA>(model: TranscriptionModel<DATA, TranscriptionModelSettings>, data: DATA, options?: FunctionOptions & {
-    returnType?: "text";
+    fullResponse?: false;
 }): Promise<string>;
 export declare function generateTranscription<DATA>(model: TranscriptionModel<DATA, TranscriptionModelSettings>, data: DATA, options: FunctionOptions & {
-    returnType: "full";
+    fullResponse: true;
 }): Promise<{
     value: string;
     response: unknown;

package/model-function/generate-transcription/generateTranscription.js

@@ -13,5 +13,5 @@ export async function generateTranscription(model, data, options) {
             };
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse ? fullResponse : fullResponse.value;
 }

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,14 +74,14 @@ 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: {
                 api_version: {
                     version: string;
                 };
             };
-            texts: string[];
-            embeddings: number[][];
         };
         embeddings: number[][];
     }>;
@@ -109,23 +109,23 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     }>;
 }, "strip", z.ZodTypeAny, {
+    texts: string[];
+    embeddings: number[][];
     id: string;
     meta: {
         api_version: {
             version: string;
         };
     };
+}, {
     texts: string[];
     embeddings: number[][];
-}, {
     id: string;
     meta: {
         api_version: {
             version: string;
         };
     };
-    texts: string[];
-    embeddings: number[][];
 }>;
 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(),