modelfusion 0.96.0 → 0.98.0

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const msw_1 = require("msw");
+const node_1 = require("msw/node");
+const streamText_js_1 = require("../../../model-function/generate-text/streamText.cjs");
+const OpenAIChatModel_js_1 = require("./OpenAIChatModel.cjs");
+const OpenAIApiConfiguration_js_1 = require("../OpenAIApiConfiguration.cjs");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let responseChunks = [];
+const server = (0, node_1.setupServer)(msw_1.http.post("https://api.openai.com/v1/chat/completions", () => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                for (const chunk of responseChunks) {
+                    controller.enqueue(encoder.encode(chunk));
+                }
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+    return new msw_1.HttpResponse(stream, {
+        status: 200,
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}));
+beforeAll(() => server.listen());
+beforeEach(() => {
+    responseChunks = [];
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+describe("streamText", () => {
+    it("should return only values from the first choice when using streamText", async () => {
+        responseChunks = [
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"A"},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"content":"B"},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","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" }),
+            model: "gpt-3.5-turbo",
+            n: 2,
+        }).withTextPrompt(), "test prompt");
+        const chunks = [];
+        for await (const part of stream) {
+            chunks.push(part);
+        }
+        expect(chunks).toStrictEqual(["A"]);
+    });
+});

package/model-provider/openai/chat/OpenAIChatModel.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,59 @@
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+import { streamText } from "../../../model-function/generate-text/streamText.js";
+import { OpenAIChatModel } from "./OpenAIChatModel.js";
+import { OpenAIApiConfiguration } from "../OpenAIApiConfiguration.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let responseChunks = [];
+const server = setupServer(http.post("https://api.openai.com/v1/chat/completions", () => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                for (const chunk of responseChunks) {
+                    controller.enqueue(encoder.encode(chunk));
+                }
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+    return new HttpResponse(stream, {
+        status: 200,
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}));
+beforeAll(() => server.listen());
+beforeEach(() => {
+    responseChunks = [];
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+describe("streamText", () => {
+    it("should return only values from the first choice when using streamText", async () => {
+        responseChunks = [
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"A"},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"content":"B"},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","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" }),
+            model: "gpt-3.5-turbo",
+            n: 2,
+        }).withTextPrompt(), "test prompt");
+        const chunks = [];
+        for await (const part of stream) {
+            chunks.push(part);
+        }
+        expect(chunks).toStrictEqual(["A"]);
+    });
+});

package/model-provider/openai/chat/OpenAIChatStreamIterable.cjs

@@ -87,18 +87,23 @@ async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaValue) {
                     continue;
                 }
                 const completionChunk = eventData;
+                // reset delta for all existing streamDeltas
+                for (const delta of streamDelta) {
+                    delta.delta = undefined;
+                }
                 for (let i = 0; i < completionChunk.choices.length; i++) {
                     const eventChoice = completionChunk.choices[i];
+                    const index = eventChoice.index;
                     const delta = eventChoice.delta;
-                    if (streamDelta[i] == null) {
-                        streamDelta[i] = {
+                    if (streamDelta[index] == null) {
+                        streamDelta[index] = {
                             role: undefined,
                             content: "",
                             isComplete: false,
                             delta,
                         };
                     }
-                    const choice = streamDelta[i];
+                    const choice = streamDelta[index];
                     choice.delta = delta;
                     if (eventChoice.finish_reason != null) {
                         choice.isComplete = true;

package/model-provider/openai/chat/OpenAIChatStreamIterable.d.ts

@@ -14,6 +14,6 @@ export type OpenAIChatDelta = Array<{
             name?: string;
             arguments?: string;
         };
-    };
+    } | undefined;
 }>;
 export declare function createOpenAIChatDeltaIterableQueue<VALUE>(stream: ReadableStream<Uint8Array>, extractDeltaValue: (delta: OpenAIChatDelta) => VALUE): Promise<AsyncIterable<Delta<VALUE>>>;

package/model-provider/openai/chat/OpenAIChatStreamIterable.js

@@ -84,18 +84,23 @@ export async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaVal
                     continue;
                 }
                 const completionChunk = eventData;
+                // reset delta for all existing streamDeltas
+                for (const delta of streamDelta) {
+                    delta.delta = undefined;
+                }
                 for (let i = 0; i < completionChunk.choices.length; i++) {
                     const eventChoice = completionChunk.choices[i];
+                    const index = eventChoice.index;
                     const delta = eventChoice.delta;
-                    if (streamDelta[i] == null) {
-                        streamDelta[i] = {
+                    if (streamDelta[index] == null) {
+                        streamDelta[index] = {
                             role: undefined,
                             content: "",
                             isComplete: false,
                             delta,
                         };
                     }
-                    const choice = streamDelta[i];
+                    const choice = streamDelta[index];
                     choice.delta = delta;
                     if (eventChoice.finish_reason != null) {
                         choice.isComplete = true;

package/package.json

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

package/tool/execute-tool/executeTool.cjs

@@ -13,7 +13,7 @@ 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?.returnType === "full" ? fullResponse : fullResponse.output;
+    return options?.fullResponse ? fullResponse : fullResponse.output;
 }
 exports.executeTool = executeTool;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

@@ -15,11 +15,11 @@ export type ExecuteToolMetadata = {
  */
 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 & {
-    returnType?: "output";
+    fullResponse?: false;
 }): 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 & {
-    returnType: "full";
+    fullResponse: true;
 }): Promise<{
     output: Awaited<ReturnType<TOOL["execute"]>>;
     metadata: ExecuteToolMetadata;

package/tool/execute-tool/executeTool.js

@@ -10,7 +10,7 @@ import { ToolExecutionError } from "../ToolExecutionError.js";
 export async function executeTool(// eslint-disable-line @typescript-eslint/no-explicit-any
 tool, args, options) {
     const fullResponse = await doExecuteTool(tool, args, options);
-    return options?.returnType === "full" ? fullResponse : fullResponse.output;
+    return options?.fullResponse ? fullResponse : fullResponse.output;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function doExecuteTool(tool, args, options) {

package/tool/generate-tool-call/TextGenerationToolCallModel.cjs

@@ -30,21 +30,21 @@ class TextGenerationToolCallModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCall(tool, prompt, options) {
-        const { response, value, metadata } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, tool), {
+        const { response, text, metadata } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, tool), {
             ...options,
-            returnType: "full",
+            fullResponse: true,
         });
         try {
             return {
                 response,
-                toolCall: this.format.extractToolCall(value),
+                toolCall: this.format.extractToolCall(text),
                 usage: metadata?.usage,
             };
         }
         catch (error) {
             throw new ToolCallParseError_js_1.ToolCallParseError({
                 toolName: tool.name,
-                valueText: value,
+                valueText: text,
                 cause: error,
             });
         }

package/tool/generate-tool-call/TextGenerationToolCallModel.js

@@ -27,21 +27,21 @@ export class TextGenerationToolCallModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCall(tool, prompt, options) {
-        const { response, value, metadata } = await generateText(this.model, this.format.createPrompt(prompt, tool), {
+        const { response, text, metadata } = await generateText(this.model, this.format.createPrompt(prompt, tool), {
             ...options,
-            returnType: "full",
+            fullResponse: true,
         });
         try {
             return {
                 response,
-                toolCall: this.format.extractToolCall(value),
+                toolCall: this.format.extractToolCall(text),
                 usage: metadata?.usage,
             };
         }
         catch (error) {
             throw new ToolCallParseError({
                 toolName: tool.name,
-                valueText: value,
+                valueText: text,
                 cause: error,
             });
         }

package/tool/generate-tool-call/generateToolCall.cjs

@@ -54,6 +54,12 @@ async function generateToolCall(model, tool, prompt, options) {
             }
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse
+        ? {
+            toolCall: fullResponse.value,
+            response: fullResponse.response,
+            metadata: fullResponse.metadata,
+        }
+        : fullResponse.value;
 }
 exports.generateToolCall = generateToolCall;

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

@@ -4,12 +4,12 @@ import { ToolCall } from "../ToolCall.js";
 import { ToolDefinition } from "../ToolDefinition.js";
 import { ToolCallGenerationModel, ToolCallGenerationModelSettings } from "./ToolCallGenerationModel.js";
 export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(model: ToolCallGenerationModel<PROMPT, SETTINGS>, tool: ToolDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT), options?: FunctionOptions & {
-    returnType?: "structure";
+    fullResponse?: false;
 }): Promise<ToolCall<NAME, PARAMETERS>>;
 export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(model: ToolCallGenerationModel<PROMPT, SETTINGS>, tool: ToolDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT), options: FunctionOptions & {
-    returnType: "full";
+    fullResponse: true;
 }): Promise<{
-    value: ToolCall<NAME, PARAMETERS>;
+    toolCall: ToolCall<NAME, PARAMETERS>;
     response: unknown;
     metadata: ModelCallMetadata;
 }>;

package/tool/generate-tool-call/generateToolCall.js

@@ -51,5 +51,11 @@ export async function generateToolCall(model, tool, prompt, options) {
             }
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse
+        ? {
+            toolCall: fullResponse.value,
+            response: fullResponse.response,
+            metadata: fullResponse.metadata,
+        }
+        : fullResponse.value;
 }

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

@@ -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.template.createPrompt(prompt, tools), {
+        const { response, text: generatedText, metadata, } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, tools), {
             ...options,
-            returnType: "full",
+            fullResponse: true,
         });
         try {
-            const { text, toolCalls } = this.template.extractToolCallsAndText(value);
+            const { text, toolCalls } = this.template.extractToolCallsAndText(generatedText);
             return {
                 response,
                 text,
@@ -45,7 +45,7 @@ class TextGenerationToolCallsOrGenerateTextModel {
         }
         catch (error) {
             throw new ToolCallsOrTextParseError_js_1.ToolCallsOrTextParseError({
-                valueText: value,
+                valueText: generatedText,
                 cause: error,
             });
         }

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

@@ -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.template.createPrompt(prompt, tools), {
+        const { response, text: generatedText, metadata, } = await generateText(this.model, this.template.createPrompt(prompt, tools), {
             ...options,
-            returnType: "full",
+            fullResponse: true,
         });
         try {
-            const { text, toolCalls } = this.template.extractToolCallsAndText(value);
+            const { text, toolCalls } = this.template.extractToolCallsAndText(generatedText);
             return {
                 response,
                 text,
@@ -42,7 +42,7 @@ export class TextGenerationToolCallsOrGenerateTextModel {
         }
         catch (error) {
             throw new ToolCallsOrTextParseError({
-                valueText: value,
+                valueText: generatedText,
                 cause: error,
             });
         }

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

@@ -58,6 +58,6 @@ async function generateToolCallsOrText(model, tools, prompt, options) {
             };
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse ? fullResponse : fullResponse.value;
 }
 exports.generateToolCallsOrText = generateToolCallsOrText;

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

@@ -15,13 +15,13 @@ type ToToolCallUnion<T> = {
 }[keyof T];
 type ToOutputValue<TOOL_CALLS extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = ToToolCallUnion<ToToolCallDefinitionMap<TOOL_CALLS>>;
 export declare function generateToolCallsOrText<TOOLS extends Array<ToolDefinition<any, any>>, PROMPT>(model: ToolCallsOrTextGenerationModel<PROMPT, ToolCallsOrTextGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions & {
-    returnType?: "structure";
+    fullResponse?: false;
 }): Promise<{
     text: string | null;
     toolCalls: Array<ToOutputValue<TOOLS>> | null;
 }>;
 export declare function generateToolCallsOrText<TOOLS extends ToolDefinition<any, any>[], PROMPT>(model: ToolCallsOrTextGenerationModel<PROMPT, ToolCallsOrTextGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options: FunctionOptions & {
-    returnType?: "full";
+    fullResponse?: boolean;
 }): Promise<{
     value: {
         text: string | null;

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

@@ -55,5 +55,5 @@ export async function generateToolCallsOrText(model, tools, prompt, options) {
             };
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse ? fullResponse : fullResponse.value;
 }

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.cjs

@@ -15,7 +15,7 @@ async function useToolsOrGenerateText(model, tools, prompt, options) {
         input: expandedPrompt,
         functionType: "use-tools-or-generate-text",
         execute: async (options) => {
-            const modelResponse = await (0, generateToolCallsOrText_js_1.generateToolCallsOrText)(model, tools, expandedPrompt, { ...options, returnType: "structure" });
+            const modelResponse = await (0, generateToolCallsOrText_js_1.generateToolCallsOrText)(model, tools, expandedPrompt, { ...options, fullResponse: false });
             const { toolCalls, text } = modelResponse;
             // no tool calls:
             if (toolCalls == null) {

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.js

@@ -12,7 +12,7 @@ export async function useToolsOrGenerateText(model, tools, prompt, options) {
         input: expandedPrompt,
         functionType: "use-tools-or-generate-text",
         execute: async (options) => {
-            const modelResponse = await generateToolCallsOrText(model, tools, expandedPrompt, { ...options, returnType: "structure" });
+            const modelResponse = await generateToolCallsOrText(model, tools, expandedPrompt, { ...options, fullResponse: false });
             const { toolCalls, text } = modelResponse;
             // no tool calls:
             if (toolCalls == null) {