modelfusion 0.92.0 → 0.93.0

package/model-provider/openai-compatible/OpenAICompatibleChatModel.d.ts

@@ -1,8 +1,8 @@
-import { StructureFromTextPromptFormat } from "../../model-function/generate-structure/StructureFromTextPromptFormat.js";
+import { StructureFromTextPromptTemplate } from "../../model-function/generate-structure/StructureFromTextPromptTemplate.js";
 import { StructureFromTextStreamingModel } from "../../model-function/generate-structure/StructureFromTextStreamingModel.js";
-import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
+import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
 import { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
-import { TextGenerationPromptFormat } from "../../model-function/generate-text/TextGenerationPromptFormat.js";
+import { TextGenerationPromptTemplate } from "../../model-function/generate-text/TextGenerationPromptTemplate.js";
 import { ToolCallGenerationModel } from "../../tool/generate-tool-call/ToolCallGenerationModel.js";
 import { ToolCallsOrTextGenerationModel } from "../../tool/generate-tool-calls-or-text/ToolCallsOrTextGenerationModel.js";
 import { AbstractOpenAIChatCallSettings, AbstractOpenAIChatModel, OpenAIChatPrompt } from "../openai/chat/AbstractOpenAIChatModel.js";
@@ -27,19 +27,19 @@ export declare class OpenAICompatibleChatModel extends AbstractOpenAIChatModel<O
     readonly tokenizer: undefined;
     readonly countPromptTokens: undefined;
     get settingsForEvent(): Partial<OpenAICompatibleChatSettings>;
-    asStructureGenerationModel<INPUT_PROMPT>(promptFormat: StructureFromTextPromptFormat<INPUT_PROMPT, OpenAIChatPrompt>): StructureFromTextStreamingModel<INPUT_PROMPT, OpenAIChatPrompt, this>;
+    asStructureGenerationModel<INPUT_PROMPT>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, OpenAIChatPrompt>): StructureFromTextStreamingModel<INPUT_PROMPT, OpenAIChatPrompt, this>;
     /**
-     * Returns this model with a text prompt format.
+     * Returns this model with a text prompt template.
      */
-    withTextPrompt(): PromptFormatTextStreamingModel<string, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
+    withTextPrompt(): PromptTemplateTextStreamingModel<string, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
     /**
-     * Returns this model with an instruction prompt format.
+     * Returns this model with an instruction prompt template.
      */
-    withInstructionPrompt(): PromptFormatTextStreamingModel<import("../../index.js").MultiModalInstructionPrompt | import("../../index.js").TextInstructionPrompt, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
+    withInstructionPrompt(): PromptTemplateTextStreamingModel<import("../../index.js").MultiModalInstructionPrompt | import("../../index.js").TextInstructionPrompt, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
     /**
-     * Returns this model with a chat prompt format.
+     * Returns this model with a chat prompt template.
      */
-    withChatPrompt(): PromptFormatTextStreamingModel<import("../../index.js").TextChatPrompt | import("../../index.js").MultiModalChatPrompt, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: TextGenerationPromptFormat<INPUT_PROMPT, OpenAIChatPrompt>): PromptFormatTextStreamingModel<INPUT_PROMPT, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
+    withChatPrompt(): PromptTemplateTextStreamingModel<import("../../index.js").TextChatPrompt | import("../../index.js").MultiModalChatPrompt, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
+    withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, OpenAIChatPrompt>): PromptTemplateTextStreamingModel<INPUT_PROMPT, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
     withSettings(additionalSettings: Partial<OpenAICompatibleChatSettings>): this;
 }

package/model-provider/openai-compatible/OpenAICompatibleChatModel.js

@@ -1,7 +1,7 @@
 import { StructureFromTextStreamingModel } from "../../model-function/generate-structure/StructureFromTextStreamingModel.js";
-import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
+import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
 import { AbstractOpenAIChatModel, } from "../openai/chat/AbstractOpenAIChatModel.js";
-import { chat, instruction, text, } from "../openai/chat/OpenAIChatPromptFormat.js";
+import { chat, instruction, text, } from "../openai/chat/OpenAIChatPromptTemplate.js";
 /**
  * Create a text generation model that calls an API that is compatible with OpenAI's chat API.
  *
@@ -55,39 +55,39 @@ export class OpenAICompatibleChatModel extends AbstractOpenAIChatModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    asStructureGenerationModel(promptFormat) {
+    asStructureGenerationModel(promptTemplate) {
         return new StructureFromTextStreamingModel({
             model: this,
-            format: promptFormat,
+            template: promptTemplate,
         });
     }
     /**
-     * Returns this model with a text prompt format.
+     * Returns this model with a text prompt template.
      */
     withTextPrompt() {
-        return this.withPromptFormat(text());
+        return this.withPromptTemplate(text());
     }
     /**
-     * Returns this model with an instruction prompt format.
+     * Returns this model with an instruction prompt template.
      */
     withInstructionPrompt() {
-        return this.withPromptFormat(instruction());
+        return this.withPromptTemplate(instruction());
     }
     /**
-     * Returns this model with a chat prompt format.
+     * Returns this model with a chat prompt template.
      */
     withChatPrompt() {
-        return this.withPromptFormat(chat());
+        return this.withPromptTemplate(chat());
     }
-    withPromptFormat(promptFormat) {
-        return new PromptFormatTextStreamingModel({
+    withPromptTemplate(promptTemplate) {
+        return new PromptTemplateTextStreamingModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),
-                    ...promptFormat.stopSequences,
+                    ...promptTemplate.stopSequences,
                 ],
             }),
-            promptFormat,
+            promptTemplate,
         });
     }
     withSettings(additionalSettings) {

package/model-provider/stability/StabilityImageGenerationModel.cjs

@@ -5,7 +5,7 @@ const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
-const PromptFormatImageGenerationModel_js_1 = require("../../model-function/generate-image/PromptFormatImageGenerationModel.cjs");
+const PromptTemplateImageGenerationModel_js_1 = require("../../model-function/generate-image/PromptTemplateImageGenerationModel.cjs");
 const StabilityApiConfiguration_js_1 = require("./StabilityApiConfiguration.cjs");
 const StabilityError_js_1 = require("./StabilityError.cjs");
 const StabilityImageGenerationPrompt_js_1 = require("./StabilityImageGenerationPrompt.cjs");
@@ -79,12 +79,12 @@ class StabilityImageGenerationModel extends AbstractModel_js_1.AbstractModel {
         };
     }
     withTextPrompt() {
-        return this.withPromptFormat((0, StabilityImageGenerationPrompt_js_1.mapBasicPromptToStabilityFormat)());
+        return this.withPromptTemplate((0, StabilityImageGenerationPrompt_js_1.mapBasicPromptToStabilityFormat)());
     }
-    withPromptFormat(promptFormat) {
-        return new PromptFormatImageGenerationModel_js_1.PromptFormatImageGenerationModel({
+    withPromptTemplate(promptTemplate) {
+        return new PromptTemplateImageGenerationModel_js_1.PromptTemplateImageGenerationModel({
             model: this,
-            promptFormat,
+            promptTemplate,
         });
     }
     withSettings(additionalSettings) {

package/model-provider/stability/StabilityImageGenerationModel.d.ts

@@ -2,9 +2,9 @@ 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 { PromptFormat } from "../../model-function/PromptFormat.js";
+import { PromptTemplate } from "../../model-function/PromptTemplate.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
-import { PromptFormatImageGenerationModel } from "../../model-function/generate-image/PromptFormatImageGenerationModel.js";
+import { PromptTemplateImageGenerationModel } from "../../model-function/generate-image/PromptTemplateImageGenerationModel.js";
 import { StabilityImageGenerationPrompt } from "./StabilityImageGenerationPrompt.js";
 /**
  * Create an image generation model that calls the Stability AI image generation API.
@@ -44,8 +44,8 @@ export declare class StabilityImageGenerationModel extends AbstractModel<Stabili
         };
         base64Image: string;
     }>;
-    withTextPrompt(): PromptFormatImageGenerationModel<string, StabilityImageGenerationPrompt, StabilityImageGenerationSettings, this>;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, StabilityImageGenerationPrompt>): PromptFormatImageGenerationModel<INPUT_PROMPT, StabilityImageGenerationPrompt, StabilityImageGenerationSettings, this>;
+    withTextPrompt(): PromptTemplateImageGenerationModel<string, StabilityImageGenerationPrompt, StabilityImageGenerationSettings, this>;
+    withPromptTemplate<INPUT_PROMPT>(promptTemplate: PromptTemplate<INPUT_PROMPT, StabilityImageGenerationPrompt>): PromptTemplateImageGenerationModel<INPUT_PROMPT, StabilityImageGenerationPrompt, StabilityImageGenerationSettings, this>;
     withSettings(additionalSettings: StabilityImageGenerationSettings): this;
 }
 declare const stabilityImageGenerationModels: readonly ["stable-diffusion-v1-5", "stable-diffusion-512-v2-1", "stable-diffusion-xl-1024-v0-9", "stable-diffusion-xl-1024-v1-0"];

package/model-provider/stability/StabilityImageGenerationModel.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { PromptFormatImageGenerationModel } from "../../model-function/generate-image/PromptFormatImageGenerationModel.js";
+import { PromptTemplateImageGenerationModel } from "../../model-function/generate-image/PromptTemplateImageGenerationModel.js";
 import { StabilityApiConfiguration } from "./StabilityApiConfiguration.js";
 import { failedStabilityCallResponseHandler } from "./StabilityError.js";
 import { mapBasicPromptToStabilityFormat, } from "./StabilityImageGenerationPrompt.js";
@@ -76,12 +76,12 @@ export class StabilityImageGenerationModel extends AbstractModel {
         };
     }
     withTextPrompt() {
-        return this.withPromptFormat(mapBasicPromptToStabilityFormat());
+        return this.withPromptTemplate(mapBasicPromptToStabilityFormat());
     }
-    withPromptFormat(promptFormat) {
-        return new PromptFormatImageGenerationModel({
+    withPromptTemplate(promptTemplate) {
+        return new PromptTemplateImageGenerationModel({
             model: this,
-            promptFormat,
+            promptTemplate,
         });
     }
     withSettings(additionalSettings) {

package/model-provider/stability/StabilityImageGenerationPrompt.d.ts

@@ -1,4 +1,4 @@
-import { PromptFormat } from "../../model-function/PromptFormat.js";
+import { PromptTemplate } from "../../model-function/PromptTemplate.js";
 export type StabilityImageGenerationPrompt = Array<{
     text: string;
     weight?: number;
@@ -6,4 +6,4 @@ export type StabilityImageGenerationPrompt = Array<{
 /**
  * Formats a basic text prompt as a Stability prompt.
  */
-export declare function mapBasicPromptToStabilityFormat(): PromptFormat<string, StabilityImageGenerationPrompt>;
+export declare function mapBasicPromptToStabilityFormat(): PromptTemplate<string, StabilityImageGenerationPrompt>;

package/model-provider/whispercpp/WhisperCppTranscriptionModel.cjs

@@ -72,15 +72,12 @@ class WhisperCppTranscriptionModel extends AbstractModel_js_1.AbstractModel {
     }
 }
 exports.WhisperCppTranscriptionModel = WhisperCppTranscriptionModel;
-const whisperCppTranscriptionJsonSchema = zod_1.z.union([
-    zod_1.z.object({ text: zod_1.z.string() }),
-    zod_1.z.object({ error: zod_1.z.string() }),
-]);
+const whisperCppTranscriptionJsonSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.union([zod_1.z.object({ text: zod_1.z.string() }), zod_1.z.object({ error: zod_1.z.string() })]));
 const successfulResponseHandler = async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
     const parsedResult = (0, parseJSON_js_1.safeParseJSON)({
         text: responseBody,
-        schema: new ZodSchema_js_1.ZodSchema(whisperCppTranscriptionJsonSchema),
+        schema: whisperCppTranscriptionJsonSchema,
     });
     if (!parsedResult.success) {
         throw new ApiCallError_js_1.ApiCallError({
@@ -106,12 +103,12 @@ const successfulResponseHandler = async ({ response, url, requestBodyValues }) =
     };
 };
 const failedResponseHandler = async ({ response, url, requestBodyValues, }) => {
-    const message = await response.text();
+    const responseBody = await response.text();
     return new ApiCallError_js_1.ApiCallError({
-        message,
+        message: responseBody,
         url,
         requestBodyValues,
         statusCode: response.status,
-        responseBody: message,
+        responseBody,
     });
 };

package/model-provider/whispercpp/WhisperCppTranscriptionModel.js

@@ -68,15 +68,12 @@ export class WhisperCppTranscriptionModel extends AbstractModel {
         return new WhisperCppTranscriptionModel(Object.assign({}, this.settings, additionalSettings));
     }
 }
-const whisperCppTranscriptionJsonSchema = z.union([
-    z.object({ text: z.string() }),
-    z.object({ error: z.string() }),
-]);
+const whisperCppTranscriptionJsonSchema = new ZodSchema(z.union([z.object({ text: z.string() }), z.object({ error: z.string() })]));
 const successfulResponseHandler = async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
     const parsedResult = safeParseJSON({
         text: responseBody,
-        schema: new ZodSchema(whisperCppTranscriptionJsonSchema),
+        schema: whisperCppTranscriptionJsonSchema,
     });
     if (!parsedResult.success) {
         throw new ApiCallError({
@@ -102,12 +99,12 @@ const successfulResponseHandler = async ({ response, url, requestBodyValues }) =
     };
 };
 const failedResponseHandler = async ({ response, url, requestBodyValues, }) => {
-    const message = await response.text();
+    const responseBody = await response.text();
     return new ApiCallError({
-        message,
+        message: responseBody,
         url,
         requestBodyValues,
         statusCode: response.status,
-        responseBody: message,
+        responseBody,
     });
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "The TypeScript library for building multi-modal AI applications.",
-  "version": "0.92.0",
+  "version": "0.93.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -62,8 +62,8 @@
     "build": "npm run build:esm && npm run build:cjs",
     "build:esm": "tsc --outDir dist/",
     "build:cjs": "tsc --outDir build/cjs/ -p tsconfig.cjs.json && node bin/prepare-cjs.js",
-    "test": "vitest run src",
-    "test-interactive": "vitest watch",
+    "test": "vitest --config vitest.config.js --run src",
+    "test:watch": "vitest watch--config vitest.config.js",
     "dist": "npm run clean && npm run lint && npm run test && npm run build && npm run dist:copy-files",
     "dist:copy-files": "copyfiles package.json README.md LICENSE dist"
   },
@@ -87,9 +87,10 @@
     "fastify": "^4.0.0",
     "husky": "^8.0.3",
     "lint-staged": "15.1.0",
+    "msw": "2.0.10",
     "prettier": "3.1.0",
     "rimraf": "5.0.5",
     "typescript": "5.2.2",
-    "vitest": "^0.34.5"
+    "vitest": "1.0.4"
   }
 }

package/tool/generate-tool-call/TextGenerationToolCallModel.d.ts

@@ -2,7 +2,7 @@ import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
 import { ToolDefinition } from "../ToolDefinition.js";
 import { ToolCallGenerationModel } from "./ToolCallGenerationModel.js";
-export interface ToolCallPromptFormat<SOURCE_PROMPT, TARGET_PROMPT> {
+export interface ToolCallPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> {
     createPrompt: (prompt: SOURCE_PROMPT, tool: ToolDefinition<string, unknown>) => TARGET_PROMPT;
     extractToolCall: (response: string) => {
         id: string;
@@ -14,7 +14,7 @@ export declare class TextGenerationToolCallModel<SOURCE_PROMPT, TARGET_PROMPT, M
     private readonly format;
     constructor({ model, format, }: {
         model: MODEL;
-        format: ToolCallPromptFormat<SOURCE_PROMPT, TARGET_PROMPT>;
+        format: ToolCallPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
     });
     get modelInformation(): import("../../index.js").ModelInformation;
     get settings(): TextGenerationModelSettings;

package/tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.cjs

@@ -4,21 +4,21 @@ exports.TextGenerationToolCallsOrGenerateTextModel = void 0;
 const generateText_js_1 = require("../../model-function/generate-text/generateText.cjs");
 const ToolCallsOrTextParseError_js_1 = require("./ToolCallsOrTextParseError.cjs");
 class TextGenerationToolCallsOrGenerateTextModel {
-    constructor({ model, format, }) {
+    constructor({ model, template, }) {
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "format", {
+        Object.defineProperty(this, "template", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
         this.model = model;
-        this.format = format;
+        this.template = template;
     }
     get modelInformation() {
         return this.model.modelInformation;
@@ -30,12 +30,12 @@ class TextGenerationToolCallsOrGenerateTextModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCallsOrText(tools, prompt, options) {
-        const { response, value, metadata } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, tools), {
+        const { response, value, metadata } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, tools), {
             ...options,
             returnType: "full",
         });
         try {
-            const { text, toolCalls } = this.format.extractToolCallsAndText(value);
+            const { text, toolCalls } = this.template.extractToolCallsAndText(value);
             return {
                 response,
                 text,
@@ -53,7 +53,7 @@ class TextGenerationToolCallsOrGenerateTextModel {
     withSettings(additionalSettings) {
         return new TextGenerationToolCallsOrGenerateTextModel({
             model: this.model.withSettings(additionalSettings),
-            format: this.format,
+            template: this.template,
         });
     }
 }

package/tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.d.ts

@@ -2,7 +2,7 @@ import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { TextGenerationModel } from "../../model-function/generate-text/TextGenerationModel.js";
 import { ToolDefinition } from "../ToolDefinition.js";
 import { ToolCallsOrTextGenerationModel, ToolCallsOrTextGenerationModelSettings } from "./ToolCallsOrTextGenerationModel.js";
-export interface ToolCallsOrGenerateTextPromptFormat<SOURCE_PROMPT, TARGET_PROMPT> {
+export interface ToolCallsOrGenerateTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> {
     createPrompt: (prompt: SOURCE_PROMPT, tools: Array<ToolDefinition<string, unknown>>) => TARGET_PROMPT;
     extractToolCallsAndText: (response: string) => {
         text: string | null;
@@ -15,10 +15,10 @@ export interface ToolCallsOrGenerateTextPromptFormat<SOURCE_PROMPT, TARGET_PROMP
 }
 export declare class TextGenerationToolCallsOrGenerateTextModel<SOURCE_PROMPT, TARGET_PROMPT, MODEL extends TextGenerationModel<TARGET_PROMPT, ToolCallsOrTextGenerationModelSettings>> implements ToolCallsOrTextGenerationModel<SOURCE_PROMPT, MODEL["settings"]> {
     private readonly model;
-    private readonly format;
-    constructor({ model, format, }: {
+    private readonly template;
+    constructor({ model, template, }: {
         model: MODEL;
-        format: ToolCallsOrGenerateTextPromptFormat<SOURCE_PROMPT, TARGET_PROMPT>;
+        template: ToolCallsOrGenerateTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
     });
     get modelInformation(): import("../../index.js").ModelInformation;
     get settings(): ToolCallsOrTextGenerationModelSettings;

package/tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.js

@@ -1,21 +1,21 @@
 import { generateText } from "../../model-function/generate-text/generateText.js";
 import { ToolCallsOrTextParseError } from "./ToolCallsOrTextParseError.js";
 export class TextGenerationToolCallsOrGenerateTextModel {
-    constructor({ model, format, }) {
+    constructor({ model, template, }) {
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "format", {
+        Object.defineProperty(this, "template", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
         this.model = model;
-        this.format = format;
+        this.template = template;
     }
     get modelInformation() {
         return this.model.modelInformation;
@@ -27,12 +27,12 @@ export class TextGenerationToolCallsOrGenerateTextModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCallsOrText(tools, prompt, options) {
-        const { response, value, metadata } = await generateText(this.model, this.format.createPrompt(prompt, tools), {
+        const { response, value, metadata } = await generateText(this.model, this.template.createPrompt(prompt, tools), {
             ...options,
             returnType: "full",
         });
         try {
-            const { text, toolCalls } = this.format.extractToolCallsAndText(value);
+            const { text, toolCalls } = this.template.extractToolCallsAndText(value);
             return {
                 response,
                 text,
@@ -50,7 +50,7 @@ export class TextGenerationToolCallsOrGenerateTextModel {
     withSettings(additionalSettings) {
         return new TextGenerationToolCallsOrGenerateTextModel({
             model: this.model.withSettings(additionalSettings),
-            format: this.format,
+            template: this.template,
         });
     }
 }

package/util/AsyncQueue.test.cjs

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
 const delay_js_1 = require("./delay.cjs");
 const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
-(0, vitest_1.test)("receive values in order for single iterator created before pushing", async () => {
+it("should receive values in order for single iterator created before pushing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     const receivedValues = [];
     const receiveValuesPromise = (async () => {
@@ -16,9 +15,9 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.push(3);
     asyncQueue.close();
     await receiveValuesPromise;
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+    expect(receivedValues).toEqual([1, 2, 3]);
 });
-(0, vitest_1.test)("receive values in order for single iterator created after closing", async () => {
+it("should receive values in order for single iterator created after closing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.push(1);
     asyncQueue.push(2);
@@ -31,9 +30,9 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
         }
     })();
     await receiveValuesPromise;
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+    expect(receivedValues).toEqual([1, 2, 3]);
 });
-(0, vitest_1.test)("handle delayed pushing", async () => {
+it("should handle delayed pushing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     setTimeout(() => {
         asyncQueue.push(1);
@@ -44,12 +43,12 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+    expect(receivedValues).toEqual([1, 2]);
 });
-(0, vitest_1.test)("error handling in consumer", async () => {
+it("should error handling in consumer", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.push(1);
-    await (0, vitest_1.expect)((async () => {
+    await expect((async () => {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         for await (const _value of asyncQueue) {
             throw new Error("Consumer error");
@@ -62,23 +61,23 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+    expect(receivedValues).toEqual([1, 2]);
 });
-(0, vitest_1.test)("behavior on empty queue closing", async () => {
+it("should behavior on empty queue closing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
     const receivedValues = [];
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([]);
+    expect(receivedValues).toEqual([]);
 });
-(0, vitest_1.test)("multiple closings", async () => {
+it("should multiple closings", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
-    (0, vitest_1.expect)(() => asyncQueue.close()).not.toThrow();
+    expect(() => asyncQueue.close()).not.toThrow();
 });
-(0, vitest_1.test)("receive all values in multiple independent consumers", async () => {
+it("should receive all values in multiple independent consumers", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     const consumerPromises = [1, 2].map(async () => {
         const receivedValues = [];
@@ -97,10 +96,10 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.close();
     const allReceivedValues = await Promise.all(consumerPromises);
     allReceivedValues.forEach((receivedValues) => {
-        (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+        expect(receivedValues).toEqual([1, 2, 3]);
     });
 });
-(0, vitest_1.test)("each consumer receives all pushed values under varying conditions", async () => {
+it("should each consumer receives all pushed values under varying conditions", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     // Start the first consumer, which will await values.
     const receivedValues1 = [];
@@ -128,11 +127,11 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.close();
     await Promise.all([consumer1, consumer2]);
     // Both consumers should have received all values, even if they started at different times.
-    (0, vitest_1.expect)(receivedValues1).toEqual([1, 2, 3]);
-    (0, vitest_1.expect)(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
+    expect(receivedValues1).toEqual([1, 2, 3]);
+    expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
 });
-(0, vitest_1.test)("throw error when pushing to a closed queue", async () => {
+it("should throw error when pushing to a closed queue", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
-    (0, vitest_1.expect)(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");
+    expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");
 });

package/util/AsyncQueue.test.js

@@ -1,7 +1,6 @@
-import { expect, test } from "vitest";
 import { delay } from "./delay.js";
 import { AsyncQueue } from "./AsyncQueue.js";
-test("receive values in order for single iterator created before pushing", async () => {
+it("should receive values in order for single iterator created before pushing", async () => {
     const asyncQueue = new AsyncQueue();
     const receivedValues = [];
     const receiveValuesPromise = (async () => {
@@ -16,7 +15,7 @@ test("receive values in order for single iterator created before pushing", async
     await receiveValuesPromise;
     expect(receivedValues).toEqual([1, 2, 3]);
 });
-test("receive values in order for single iterator created after closing", async () => {
+it("should receive values in order for single iterator created after closing", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.push(1);
     asyncQueue.push(2);
@@ -31,7 +30,7 @@ test("receive values in order for single iterator created after closing", async
     await receiveValuesPromise;
     expect(receivedValues).toEqual([1, 2, 3]);
 });
-test("handle delayed pushing", async () => {
+it("should handle delayed pushing", async () => {
     const asyncQueue = new AsyncQueue();
     setTimeout(() => {
         asyncQueue.push(1);
@@ -44,7 +43,7 @@ test("handle delayed pushing", async () => {
     }
     expect(receivedValues).toEqual([1, 2]);
 });
-test("error handling in consumer", async () => {
+it("should error handling in consumer", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.push(1);
     await expect((async () => {
@@ -62,7 +61,7 @@ test("error handling in consumer", async () => {
     }
     expect(receivedValues).toEqual([1, 2]);
 });
-test("behavior on empty queue closing", async () => {
+it("should behavior on empty queue closing", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     const receivedValues = [];
@@ -71,12 +70,12 @@ test("behavior on empty queue closing", async () => {
     }
     expect(receivedValues).toEqual([]);
 });
-test("multiple closings", async () => {
+it("should multiple closings", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     expect(() => asyncQueue.close()).not.toThrow();
 });
-test("receive all values in multiple independent consumers", async () => {
+it("should receive all values in multiple independent consumers", async () => {
     const asyncQueue = new AsyncQueue();
     const consumerPromises = [1, 2].map(async () => {
         const receivedValues = [];
@@ -98,7 +97,7 @@ test("receive all values in multiple independent consumers", async () => {
         expect(receivedValues).toEqual([1, 2, 3]);
     });
 });
-test("each consumer receives all pushed values under varying conditions", async () => {
+it("should each consumer receives all pushed values under varying conditions", async () => {
     const asyncQueue = new AsyncQueue();
     // Start the first consumer, which will await values.
     const receivedValues1 = [];
@@ -129,7 +128,7 @@ test("each consumer receives all pushed values under varying conditions", async
     expect(receivedValues1).toEqual([1, 2, 3]);
     expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
 });
-test("throw error when pushing to a closed queue", async () => {
+it("should throw error when pushing to a closed queue", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");