modelfusion 0.121.2 → 0.123.0

package/model-provider/ollama/OllamaChatModel.d.ts

@@ -40,11 +40,11 @@ export declare class OllamaChatModel extends AbstractModel<OllamaChatModelSettin
     get settingsForEvent(): Partial<OllamaChatModelSettings>;
     doGenerateTexts(prompt: OllamaChatPrompt, options: FunctionCallOptions): Promise<{
         rawResponse: {
-            model: string;
             message: {
                 role: string;
                 content: string;
             };
+            model: string;
             done: true;
             created_at: string;
             total_duration: number;
@@ -61,11 +61,11 @@ export declare class OllamaChatModel extends AbstractModel<OllamaChatModelSettin
     }>;
     restoreGeneratedTexts(rawResponse: unknown): {
         rawResponse: {
-            model: string;
             message: {
                 role: string;
                 content: string;
             };
+            model: string;
             done: true;
             created_at: string;
             total_duration: number;
@@ -82,11 +82,11 @@ export declare class OllamaChatModel extends AbstractModel<OllamaChatModelSettin
     };
     private processTextGenerationResponse;
     doStreamText(prompt: OllamaChatPrompt, options: FunctionCallOptions): Promise<AsyncIterable<import("../../index.js").Delta<{
-        model: string;
         message: {
             role: string;
             content: string;
         };
+        model: string;
         done: false;
         created_at: string;
     } | {
@@ -141,11 +141,11 @@ declare const ollamaChatResponseSchema: z.ZodObject<{
     eval_count: z.ZodNumber;
     eval_duration: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    model: string;
     message: {
         role: string;
         content: string;
     };
+    model: string;
     done: true;
     created_at: string;
     total_duration: number;
@@ -155,11 +155,11 @@ declare const ollamaChatResponseSchema: z.ZodObject<{
     prompt_eval_count?: number | undefined;
     prompt_eval_duration?: number | undefined;
 }, {
-    model: string;
     message: {
         role: string;
         content: string;
     };
+    model: string;
     done: true;
     created_at: string;
     total_duration: number;
@@ -185,19 +185,19 @@ declare const ollamaChatStreamChunkSchema: z.ZodDiscriminatedUnion<"done", [z.Zo
         content: string;
     }>;
 }, "strip", z.ZodTypeAny, {
-    model: string;
     message: {
         role: string;
         content: string;
     };
+    model: string;
     done: false;
     created_at: string;
 }, {
-    model: string;
     message: {
         role: string;
         content: string;
     };
+    model: string;
     done: false;
     created_at: string;
 }>, z.ZodObject<{
@@ -247,11 +247,11 @@ export declare const OllamaChatResponseFormat: {
             requestBodyValues: unknown;
             response: Response;
         }) => Promise<{
-            model: string;
             message: {
                 role: string;
                 content: string;
             };
+            model: string;
             done: true;
             created_at: string;
             total_duration: number;
@@ -271,11 +271,11 @@ export declare const OllamaChatResponseFormat: {
         handler: ({ response }: {
             response: Response;
         }) => Promise<AsyncIterable<import("../../index.js").Delta<{
-            model: string;
             message: {
                 role: string;
                 content: string;
             };
+            model: string;
             done: false;
             created_at: string;
         } | {

package/model-provider/ollama/OllamaChatModel.test.cjs

@@ -16,7 +16,12 @@ describe("streamText", () => {
                 `"done":true,"total_duration":4843619375,"load_duration":1101458,"prompt_eval_count":5,"prompt_eval_duration":199339000,` +
                 `"eval_count":317,"eval_duration":4639772000}\n`,
         ];
-        const stream = await (0, streamText_js_1.streamText)(new OllamaChatModel_js_1.OllamaChatModel({ model: "mistral:text" }).withTextPrompt(), "hello");
+        const stream = await (0, streamText_js_1.streamText)({
+            model: new OllamaChatModel_js_1.OllamaChatModel({
+                model: "mistral:text",
+            }).withTextPrompt(),
+            prompt: "hello",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await (0, arrayFromAsync_js_1.arrayFromAsync)(stream)).toStrictEqual([
             "Hello",

package/model-provider/ollama/OllamaChatModel.test.js

@@ -14,7 +14,12 @@ describe("streamText", () => {
                 `"done":true,"total_duration":4843619375,"load_duration":1101458,"prompt_eval_count":5,"prompt_eval_duration":199339000,` +
                 `"eval_count":317,"eval_duration":4639772000}\n`,
         ];
-        const stream = await streamText(new OllamaChatModel({ model: "mistral:text" }).withTextPrompt(), "hello");
+        const stream = await streamText({
+            model: new OllamaChatModel({
+                model: "mistral:text",
+            }).withTextPrompt(),
+            prompt: "hello",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await arrayFromAsync(stream)).toStrictEqual([
             "Hello",

package/model-provider/ollama/OllamaCompletionModel.test.cjs

@@ -34,9 +34,12 @@ describe("generateText", () => {
             eval_count: 113,
             eval_duration: 1325948000,
         };
-        const result = await (0, generateText_js_1.generateText)(new OllamaCompletionModel_js_1.OllamaCompletionModel({
-            model: "test-model",
-        }).withTextPrompt(), "test prompt");
+        const result = await (0, generateText_js_1.generateText)({
+            model: new OllamaCompletionModel_js_1.OllamaCompletionModel({
+                model: "test-model",
+            }).withTextPrompt(),
+            prompt: "test prompt",
+        });
         expect(result).toEqual("test response");
     });
     it("should throw retryable ApiCallError when Ollama is overloaded", async () => {
@@ -47,12 +50,15 @@ describe("generateText", () => {
             done: false,
         };
         try {
-            await (0, generateText_js_1.generateText)(new OllamaCompletionModel_js_1.OllamaCompletionModel({
-                api: new OllamaApiConfiguration_js_1.OllamaApiConfiguration({
-                    retry: (0, retryNever_js_1.retryNever)(),
-                }),
-                model: "test-model",
-            }).withTextPrompt(), "test prompt");
+            await (0, generateText_js_1.generateText)({
+                model: new OllamaCompletionModel_js_1.OllamaCompletionModel({
+                    api: new OllamaApiConfiguration_js_1.OllamaApiConfiguration({
+                        retry: (0, retryNever_js_1.retryNever)(),
+                    }),
+                    model: "test-model",
+                }).withTextPrompt(),
+                prompt: "test prompt",
+            });
             (0, assert_1.fail)("Should have thrown ApiCallError");
         }
         catch (expectedError) {
@@ -73,7 +79,12 @@ describe("streamText", () => {
                 `"done":true,"context":[123,456,789],"total_duration":2165354041,"load_duration":1293958,` +
                 `"prompt_eval_count":5,"prompt_eval_duration":193273000,"eval_count":136,"eval_duration":1966852000}\n`,
         ];
-        const stream = await (0, streamText_js_1.streamText)(new OllamaCompletionModel_js_1.OllamaCompletionModel({ model: "mistral:text" }).withTextPrompt(), "hello");
+        const stream = await (0, streamText_js_1.streamText)({
+            model: new OllamaCompletionModel_js_1.OllamaCompletionModel({
+                model: "mistral:text",
+            }).withTextPrompt(),
+            prompt: "hello",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await (0, arrayFromAsync_js_1.arrayFromAsync)(stream)).toStrictEqual([
             "Hello",
@@ -103,12 +114,16 @@ describe("streamStructure", () => {
                 `"total_duration":521893000,"load_duration":957666,"prompt_eval_count":74,"prompt_eval_duration":302508000,` +
                 `"eval_count":12,"eval_duration":215282000}\n`,
         ];
-        const stream = await (0, streamStructure_js_1.streamStructure)(new OllamaCompletionModel_js_1.OllamaCompletionModel({
-            model: "mistral:text",
-            promptTemplate: OllamaCompletionPrompt_js_1.Text,
-            format: "json",
-            raw: true,
-        }).asStructureGenerationModel(jsonStructurePrompt_js_1.jsonStructurePrompt.text()), (0, ZodSchema_js_1.zodSchema)(zod_1.z.object({ name: zod_1.z.string() })), "generate a name");
+        const stream = await (0, streamStructure_js_1.streamStructure)({
+            model: new OllamaCompletionModel_js_1.OllamaCompletionModel({
+                model: "mistral:text",
+                promptTemplate: OllamaCompletionPrompt_js_1.Text,
+                format: "json",
+                raw: true,
+            }).asStructureGenerationModel(jsonStructurePrompt_js_1.jsonStructurePrompt.text()),
+            schema: (0, ZodSchema_js_1.zodSchema)(zod_1.z.object({ name: zod_1.z.string() })),
+            prompt: "generate a name",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await (0, arrayFromAsync_js_1.arrayFromAsync)(stream)).toStrictEqual([
             { isComplete: false, value: {} },

package/model-provider/ollama/OllamaCompletionModel.test.js

@@ -32,9 +32,12 @@ describe("generateText", () => {
             eval_count: 113,
             eval_duration: 1325948000,
         };
-        const result = await generateText(new OllamaCompletionModel({
-            model: "test-model",
-        }).withTextPrompt(), "test prompt");
+        const result = await generateText({
+            model: new OllamaCompletionModel({
+                model: "test-model",
+            }).withTextPrompt(),
+            prompt: "test prompt",
+        });
         expect(result).toEqual("test response");
     });
     it("should throw retryable ApiCallError when Ollama is overloaded", async () => {
@@ -45,12 +48,15 @@ describe("generateText", () => {
             done: false,
         };
         try {
-            await generateText(new OllamaCompletionModel({
-                api: new OllamaApiConfiguration({
-                    retry: retryNever(),
-                }),
-                model: "test-model",
-            }).withTextPrompt(), "test prompt");
+            await generateText({
+                model: new OllamaCompletionModel({
+                    api: new OllamaApiConfiguration({
+                        retry: retryNever(),
+                    }),
+                    model: "test-model",
+                }).withTextPrompt(),
+                prompt: "test prompt",
+            });
             fail("Should have thrown ApiCallError");
         }
         catch (expectedError) {
@@ -71,7 +77,12 @@ describe("streamText", () => {
                 `"done":true,"context":[123,456,789],"total_duration":2165354041,"load_duration":1293958,` +
                 `"prompt_eval_count":5,"prompt_eval_duration":193273000,"eval_count":136,"eval_duration":1966852000}\n`,
         ];
-        const stream = await streamText(new OllamaCompletionModel({ model: "mistral:text" }).withTextPrompt(), "hello");
+        const stream = await streamText({
+            model: new OllamaCompletionModel({
+                model: "mistral:text",
+            }).withTextPrompt(),
+            prompt: "hello",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await arrayFromAsync(stream)).toStrictEqual([
             "Hello",
@@ -101,12 +112,16 @@ describe("streamStructure", () => {
                 `"total_duration":521893000,"load_duration":957666,"prompt_eval_count":74,"prompt_eval_duration":302508000,` +
                 `"eval_count":12,"eval_duration":215282000}\n`,
         ];
-        const stream = await streamStructure(new OllamaCompletionModel({
-            model: "mistral:text",
-            promptTemplate: Text,
-            format: "json",
-            raw: true,
-        }).asStructureGenerationModel(jsonStructurePrompt.text()), zodSchema(z.object({ name: z.string() })), "generate a name");
+        const stream = await streamStructure({
+            model: new OllamaCompletionModel({
+                model: "mistral:text",
+                promptTemplate: Text,
+                format: "json",
+                raw: true,
+            }).asStructureGenerationModel(jsonStructurePrompt.text()),
+            schema: zodSchema(z.object({ name: z.string() })),
+            prompt: "generate a name",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await arrayFromAsync(stream)).toStrictEqual([
             { isComplete: false, value: {} },

package/model-provider/openai/OpenAIChatFunctionCallStructureGenerationModel.cjs

@@ -101,7 +101,7 @@ class OpenAIChatFunctionCallStructureGenerationModel {
     async doGenerateStructure(schema, prompt, // first argument of the function
     options) {
         const expandedPrompt = this.promptTemplate.format(prompt);
-        const response = await this.model
+        const rawResponse = await this.model
             .withSettings({
             stopSequences: [
                 ...(this.settings.stopSequences ?? []),
@@ -119,13 +119,13 @@ class OpenAIChatFunctionCallStructureGenerationModel {
                 },
             ],
         });
-        const valueText = response.choices[0].message.function_call.arguments;
+        const valueText = rawResponse.choices[0].message.function_call.arguments;
         try {
             return {
-                response,
+                rawResponse,
                 valueText,
                 value: secure_json_parse_1.default.parse(valueText),
-                usage: this.model.extractUsage(response),
+                usage: this.model.extractUsage(rawResponse),
             };
         }
         catch (error) {

package/model-provider/openai/OpenAIChatFunctionCallStructureGenerationModel.d.ts

@@ -127,7 +127,7 @@ OpenAIChatSettings> {
      */
     doGenerateStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: Parameters<PROMPT_TEMPLATE["format"]>[0], // first argument of the function
     options: FunctionCallOptions): Promise<{
-        response: {
+        rawResponse: {
             object: "chat.completion";
             model: string;
             usage: {

package/model-provider/openai/OpenAIChatFunctionCallStructureGenerationModel.js

@@ -95,7 +95,7 @@ export class OpenAIChatFunctionCallStructureGenerationModel {
     async doGenerateStructure(schema, prompt, // first argument of the function
     options) {
         const expandedPrompt = this.promptTemplate.format(prompt);
-        const response = await this.model
+        const rawResponse = await this.model
             .withSettings({
             stopSequences: [
                 ...(this.settings.stopSequences ?? []),
@@ -113,13 +113,13 @@ export class OpenAIChatFunctionCallStructureGenerationModel {
                 },
             ],
         });
-        const valueText = response.choices[0].message.function_call.arguments;
+        const valueText = rawResponse.choices[0].message.function_call.arguments;
         try {
             return {
-                response,
+                rawResponse,
                 valueText,
                 value: SecureJSON.parse(valueText),
-                usage: this.model.extractUsage(response),
+                usage: this.model.extractUsage(rawResponse),
             };
         }
         catch (error) {

package/model-provider/openai/OpenAIChatModel.test.cjs

@@ -27,11 +27,14 @@ describe("streamText", () => {
                 `"system_fingerprint":null,"choices":[{"index":1,"delta":{},"finish_reason":"stop"}]}\n\n`,
             "data: [DONE]\n\n",
         ];
-        const stream = await (0, streamText_js_1.streamText)(new OpenAIChatModel_js_1.OpenAIChatModel({
-            api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test-key" }),
-            model: "gpt-3.5-turbo",
-            numberOfGenerations: 2,
-        }).withTextPrompt(), "test prompt");
+        const stream = await (0, streamText_js_1.streamText)({
+            model: new OpenAIChatModel_js_1.OpenAIChatModel({
+                api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test-key" }),
+                model: "gpt-3.5-turbo",
+                numberOfGenerations: 2,
+            }).withTextPrompt(),
+            prompt: "test prompt",
+        });
         expect(await (0, arrayFromAsync_js_1.arrayFromAsync)(stream)).toStrictEqual(["A"]);
     });
 });
@@ -73,15 +76,19 @@ describe("streamStructure", () => {
                 `"choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}\n\n`,
             `data: [DONE]\n\n`,
         ];
-        const stream = await (0, streamStructure_js_1.streamStructure)(new OpenAIChatModel_js_1.OpenAIChatModel({
-            api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test-key" }),
-            model: "gpt-3.5-turbo",
-        })
-            .asFunctionCallStructureGenerationModel({
-            fnName: "generateCharacter",
-            fnDescription: "Generate character descriptions.",
-        })
-            .withTextPrompt(), (0, ZodSchema_js_1.zodSchema)(zod_1.z.object({ name: zod_1.z.string() })), "generate a name");
+        const stream = await (0, streamStructure_js_1.streamStructure)({
+            model: new OpenAIChatModel_js_1.OpenAIChatModel({
+                api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test-key" }),
+                model: "gpt-3.5-turbo",
+            })
+                .asFunctionCallStructureGenerationModel({
+                fnName: "generateCharacter",
+                fnDescription: "Generate character descriptions.",
+            })
+                .withTextPrompt(),
+            schema: (0, ZodSchema_js_1.zodSchema)(zod_1.z.object({ name: zod_1.z.string() })),
+            prompt: "generate a name",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await (0, arrayFromAsync_js_1.arrayFromAsync)(stream)).toStrictEqual([
             { isComplete: false, value: {} },

package/model-provider/openai/OpenAIChatModel.test.js

@@ -25,11 +25,14 @@ describe("streamText", () => {
                 `"system_fingerprint":null,"choices":[{"index":1,"delta":{},"finish_reason":"stop"}]}\n\n`,
             "data: [DONE]\n\n",
         ];
-        const stream = await streamText(new OpenAIChatModel({
-            api: new OpenAIApiConfiguration({ apiKey: "test-key" }),
-            model: "gpt-3.5-turbo",
-            numberOfGenerations: 2,
-        }).withTextPrompt(), "test prompt");
+        const stream = await streamText({
+            model: new OpenAIChatModel({
+                api: new OpenAIApiConfiguration({ apiKey: "test-key" }),
+                model: "gpt-3.5-turbo",
+                numberOfGenerations: 2,
+            }).withTextPrompt(),
+            prompt: "test prompt",
+        });
         expect(await arrayFromAsync(stream)).toStrictEqual(["A"]);
     });
 });
@@ -71,15 +74,19 @@ describe("streamStructure", () => {
                 `"choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}\n\n`,
             `data: [DONE]\n\n`,
         ];
-        const stream = await streamStructure(new OpenAIChatModel({
-            api: new OpenAIApiConfiguration({ apiKey: "test-key" }),
-            model: "gpt-3.5-turbo",
-        })
-            .asFunctionCallStructureGenerationModel({
-            fnName: "generateCharacter",
-            fnDescription: "Generate character descriptions.",
-        })
-            .withTextPrompt(), zodSchema(z.object({ name: z.string() })), "generate a name");
+        const stream = await streamStructure({
+            model: new OpenAIChatModel({
+                api: new OpenAIApiConfiguration({ apiKey: "test-key" }),
+                model: "gpt-3.5-turbo",
+            })
+                .asFunctionCallStructureGenerationModel({
+                fnName: "generateCharacter",
+                fnDescription: "Generate character descriptions.",
+            })
+                .withTextPrompt(),
+            schema: zodSchema(z.object({ name: z.string() })),
+            prompt: "generate a name",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await arrayFromAsync(stream)).toStrictEqual([
             { isComplete: false, value: {} },

package/model-provider/openai/OpenAICompletionModel.test.cjs

@@ -20,10 +20,13 @@ describe("streamText", () => {
                 `"choices":[{"text":"","index":0,"logprobs":null,"finish_reason":"length"}],"model":"gpt-3.5-turbo-instruct"}\n\n`,
             "data: [DONE]\n\n",
         ];
-        const stream = await (0, streamText_js_1.streamText)(new OpenAICompletionModel_js_1.OpenAICompletionModel({
-            api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test-key" }),
-            model: "gpt-3.5-turbo-instruct",
-        }), "hello");
+        const stream = await (0, streamText_js_1.streamText)({
+            model: new OpenAICompletionModel_js_1.OpenAICompletionModel({
+                api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test-key" }),
+                model: "gpt-3.5-turbo-instruct",
+            }),
+            prompt: "hello",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await (0, arrayFromAsync_js_1.arrayFromAsync)(stream)).toStrictEqual([
             "Hello",
@@ -43,11 +46,14 @@ describe("streamText", () => {
                 `"choices":[{"text":"","index":1,"logprobs":null,"finish_reason":"length"}],"model":"gpt-3.5-turbo-instruct"}\n\n`,
             "data: [DONE]\n\n",
         ];
-        const stream = await (0, streamText_js_1.streamText)(new OpenAICompletionModel_js_1.OpenAICompletionModel({
-            api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test-key" }),
-            model: "gpt-3.5-turbo-instruct",
-            numberOfGenerations: 2,
-        }), "test prompt");
+        const stream = await (0, streamText_js_1.streamText)({
+            model: new OpenAICompletionModel_js_1.OpenAICompletionModel({
+                api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test-key" }),
+                model: "gpt-3.5-turbo-instruct",
+                numberOfGenerations: 2,
+            }),
+            prompt: "test prompt",
+        });
         expect(await (0, arrayFromAsync_js_1.arrayFromAsync)(stream)).toStrictEqual(["A"]);
     });
 });

package/model-provider/openai/OpenAICompletionModel.test.js

@@ -18,10 +18,13 @@ describe("streamText", () => {
                 `"choices":[{"text":"","index":0,"logprobs":null,"finish_reason":"length"}],"model":"gpt-3.5-turbo-instruct"}\n\n`,
             "data: [DONE]\n\n",
         ];
-        const stream = await streamText(new OpenAICompletionModel({
-            api: new OpenAIApiConfiguration({ apiKey: "test-key" }),
-            model: "gpt-3.5-turbo-instruct",
-        }), "hello");
+        const stream = await streamText({
+            model: new OpenAICompletionModel({
+                api: new OpenAIApiConfiguration({ apiKey: "test-key" }),
+                model: "gpt-3.5-turbo-instruct",
+            }),
+            prompt: "hello",
+        });
         // note: space moved to last chunk bc of trimming
         expect(await arrayFromAsync(stream)).toStrictEqual([
             "Hello",
@@ -41,11 +44,14 @@ describe("streamText", () => {
                 `"choices":[{"text":"","index":1,"logprobs":null,"finish_reason":"length"}],"model":"gpt-3.5-turbo-instruct"}\n\n`,
             "data: [DONE]\n\n",
         ];
-        const stream = await streamText(new OpenAICompletionModel({
-            api: new OpenAIApiConfiguration({ apiKey: "test-key" }),
-            model: "gpt-3.5-turbo-instruct",
-            numberOfGenerations: 2,
-        }), "test prompt");
+        const stream = await streamText({
+            model: new OpenAICompletionModel({
+                api: new OpenAIApiConfiguration({ apiKey: "test-key" }),
+                model: "gpt-3.5-turbo-instruct",
+                numberOfGenerations: 2,
+            }),
+            prompt: "test prompt",
+        });
         expect(await arrayFromAsync(stream)).toStrictEqual(["A"]);
     });
 });

package/model-provider/openai/OpenAITextEmbeddingModel.d.ts

@@ -52,16 +52,16 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     doEmbedValues(texts: string[], callOptions: FunctionCallOptions): Promise<{
         rawResponse: {
             object: "list";
-            model: string;
-            usage: {
-                prompt_tokens: number;
-                total_tokens: number;
-            };
             data: {
                 object: "embedding";
                 embedding: number[];
                 index: number;
             }[];
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                total_tokens: number;
+            };
         };
         embeddings: number[][];
     }>;
@@ -95,28 +95,28 @@ declare const openAITextEmbeddingResponseSchema: z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     object: "list";
-    model: string;
-    usage: {
-        prompt_tokens: number;
-        total_tokens: number;
-    };
     data: {
         object: "embedding";
         embedding: number[];
         index: number;
     }[];
-}, {
-    object: "list";
     model: string;
     usage: {
         prompt_tokens: number;
         total_tokens: number;
     };
+}, {
+    object: "list";
     data: {
         object: "embedding";
         embedding: number[];
         index: number;
     }[];
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
 }>;
 export type OpenAITextEmbeddingResponse = z.infer<typeof openAITextEmbeddingResponseSchema>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "The TypeScript library for building AI applications.",
-  "version": "0.121.2",
+  "version": "0.123.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/tool/execute-tool/executeTool.cjs

@@ -10,14 +10,14 @@ const getRun_js_1 = require("../../core/getRun.cjs");
 const DurationMeasurement_js_1 = require("../../util/DurationMeasurement.cjs");
 const runSafe_js_1 = require("../../util/runSafe.cjs");
 const ToolExecutionError_js_1 = require("../ToolExecutionError.cjs");
-async function executeTool(// eslint-disable-line @typescript-eslint/no-explicit-any
-tool, args, options) {
-    const fullResponse = await doExecuteTool(tool, args, options);
-    return options?.fullResponse ? fullResponse : fullResponse.output;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function executeTool({ tool, args, fullResponse, ...options }) {
+    const callResponse = await doExecuteTool({ tool, args, ...options });
+    return fullResponse ? callResponse : callResponse.output;
 }
 exports.executeTool = executeTool;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function doExecuteTool(tool, args, options) {
+async function doExecuteTool({ tool, args, ...options }) {
     const run = await (0, getRun_js_1.getRun)(options?.run);
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
         observers: [

package/tool/execute-tool/executeTool.d.ts

@@ -14,13 +14,17 @@ export type ExecuteToolMetadata = {
  * `executeTool` executes a tool with the given parameters.
  */
 export declare function executeTool<TOOL extends Tool<any, any, any>>(// eslint-disable-line @typescript-eslint/no-explicit-any
-tool: TOOL, args: TOOL["parameters"]["_type"], options?: FunctionOptions & {
+params: {
+    tool: TOOL;
+    args: TOOL["parameters"]["_type"];
     fullResponse?: false;
-}): Promise<ReturnType<TOOL["execute"]>>;
+} & FunctionOptions): Promise<ReturnType<TOOL["execute"]>>;
 export declare function executeTool<TOOL extends Tool<any, any, any>>(// eslint-disable-line @typescript-eslint/no-explicit-any
-tool: TOOL, args: TOOL["parameters"]["_type"], options: FunctionOptions & {
+params: {
+    tool: TOOL;
+    args: TOOL["parameters"]["_type"];
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     output: Awaited<ReturnType<TOOL["execute"]>>;
     metadata: ExecuteToolMetadata;
 }>;