modelfusion 0.40.0 → 0.41.0

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

@@ -10,7 +10,7 @@ const callWithRetryAndThrottle_js_1 = require("../../../core/api/callWithRetryAn
 const postToApi_js_1 = require("../../../core/api/postToApi.cjs");
 const AbstractModel_js_1 = require("../../../model-function/AbstractModel.cjs");
 const parsePartialJson_js_1 = require("../../../model-function/generate-structure/parsePartialJson.cjs");
-const PromptFormatTextGenerationModel_js_1 = require("../../../prompt/PromptFormatTextGenerationModel.cjs");
+const PromptFormatTextStreamingModel_js_1 = require("../../../prompt/PromptFormatTextStreamingModel.cjs");
 const OpenAIApiConfiguration_js_1 = require("../OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("../OpenAIError.cjs");
 const TikTokenTokenizer_js_1 = require("../TikTokenTokenizer.cjs");
@@ -183,27 +183,25 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         });
     }
     async callAPI(messages, options) {
-        const { run, settings, responseFormat } = options;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // map to OpenAI API names:
-            stop: combinedSettings.stopSequences,
-            maxTokens: combinedSettings.maxCompletionTokens,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            messages,
-            responseFormat,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAIChatCompletionAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAIChatCompletionAPI({
+                ...this.settings,
+                // function calling:
+                functions: options.functions ?? this.settings.functions,
+                functionCall: options.functionCall ?? this.settings.functionCall,
+                // map to OpenAI API names:
+                stop: this.settings.stopSequences,
+                maxTokens: this.settings.maxCompletionTokens,
+                // other settings:
+                user: this.settings.isUserIdForwardingEnabled
+                    ? options.run?.userId
+                    : undefined,
+                abortSignal: options.run?.abortSignal,
+                responseFormat: options.responseFormat,
+                messages,
+            }),
         });
     }
     get settingsForEvent() {
@@ -221,24 +219,23 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: exports.OpenAIChatResponseFormat.json,
         });
+        return {
+            response,
+            text: response.choices[0].message.content,
+            usage: this.extractUsage(response),
+        };
     }
-    extractText(response) {
-        return response.choices[0].message.content;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
-            responseFormat: exports.OpenAIChatResponseFormat.deltaIterable,
+            responseFormat: exports.OpenAIChatResponseFormat.textDeltaIterable,
         });
     }
-    extractTextDelta(fullDelta) {
-        return fullDelta[0]?.delta.content ?? undefined;
-    }
     /**
      * JSON generation uses the OpenAI GPT function calling API.
      * It provides a single function specification and instructs the model to provide parameters for calling the function.
@@ -246,69 +243,54 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
      *
      * @see https://platform.openai.com/docs/guides/gpt/function-calling
      */
-    generateStructureResponse(structureDefinition, prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateStructure(structureDefinition, prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
             responseFormat: exports.OpenAIChatResponseFormat.json,
-            functionId: options?.functionId,
-            settings: {
-                ...options,
-                functionCall: { name: structureDefinition.name },
-                functions: [
-                    {
-                        name: structureDefinition.name,
-                        description: structureDefinition.description,
-                        parameters: structureDefinition.schema.getJsonSchema(),
-                    },
-                ],
-            },
-            run: options?.run,
-        });
-    }
-    extractStructure(response) {
-        return secure_json_parse_1.default.parse(response.choices[0].message.function_call.arguments);
-    }
-    generateStructureStreamResponse(structureDefinition, prompt, options) {
-        return this.callAPI(prompt, {
-            responseFormat: exports.OpenAIChatResponseFormat.deltaIterable,
-            functionId: options?.functionId,
-            settings: {
-                ...options,
-                functionCall: { name: structureDefinition.name },
-                functions: [
-                    {
-                        name: structureDefinition.name,
-                        description: structureDefinition.description,
-                        parameters: structureDefinition.schema.getJsonSchema(),
-                    },
-                ],
-            },
-            run: options?.run,
+            functionCall: { name: structureDefinition.name },
+            functions: [
+                {
+                    name: structureDefinition.name,
+                    description: structureDefinition.description,
+                    parameters: structureDefinition.schema.getJsonSchema(),
+                },
+            ],
         });
+        return {
+            response,
+            structure: secure_json_parse_1.default.parse(response.choices[0].message.function_call.arguments),
+            usage: this.extractUsage(response),
+        };
     }
-    extractPartialStructure(fullDelta) {
-        return (0, parsePartialJson_js_1.parsePartialJson)(fullDelta[0]?.function_call?.arguments);
-    }
-    generateStructureOrTextResponse(structureDefinitions, prompt, options) {
+    async doStreamStructure(structureDefinition, prompt, options) {
         return this.callAPI(prompt, {
-            responseFormat: exports.OpenAIChatResponseFormat.json,
-            functionId: options?.functionId,
-            settings: {
-                ...options,
-                functionCall: "auto",
-                functions: structureDefinitions.map((structureDefinition) => ({
+            ...options,
+            responseFormat: exports.OpenAIChatResponseFormat.structureDeltaIterable,
+            functionCall: { name: structureDefinition.name },
+            functions: [
+                {
                     name: structureDefinition.name,
                     description: structureDefinition.description,
                     parameters: structureDefinition.schema.getJsonSchema(),
-                })),
-            },
-            run: options?.run,
+                },
+            ],
         });
     }
-    extractStructureAndText(response) {
+    async doGenerateStructureOrText(structureDefinitions, prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.OpenAIChatResponseFormat.json,
+            functionCall: "auto",
+            functions: structureDefinitions.map((structureDefinition) => ({
+                name: structureDefinition.name,
+                description: structureDefinition.description,
+                parameters: structureDefinition.schema.getJsonSchema(),
+            })),
+        });
         const message = response.choices[0].message;
         const content = message.content;
         const functionCall = message.function_call;
-        return functionCall == null
+        const structureAndText = functionCall == null
             ? {
                 structure: null,
                 value: null,
@@ -319,6 +301,11 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
                 value: secure_json_parse_1.default.parse(functionCall.arguments),
                 text: content,
             };
+        return {
+            response,
+            structureAndText,
+            usage: this.extractUsage(response),
+        };
     }
     extractUsage(response) {
         return {
@@ -328,8 +315,13 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         };
     }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
-            model: this.withSettings({ stopSequences: promptFormat.stopSequences }),
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
             promptFormat,
         });
     }
@@ -404,8 +396,12 @@ exports.OpenAIChatResponseFormat = {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    deltaIterable: {
+    textDeltaIterable: {
+        stream: true,
+        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => delta[0]?.delta.content ?? ""),
+    },
+    structureDeltaIterable: {
         stream: true,
-        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatFullDeltaIterableQueue)(response.body),
+        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => (0, parsePartialJson_js_1.parsePartialJson)(delta[0]?.function_call?.arguments)),
     },
 };

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

@@ -1,18 +1,17 @@
 import z from "zod";
+import { FunctionOptions } from "../../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../../core/api/ApiConfiguration.js";
 import { ResponseHandler } from "../../../core/api/postToApi.js";
 import { StructureDefinition } from "../../../core/structure/StructureDefinition.js";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
-import { DeltaEvent } from "../../../model-function/DeltaEvent.js";
-import { ModelFunctionOptions } from "../../../model-function/ModelFunctionOptions.js";
+import { Delta } from "../../../model-function/Delta.js";
 import { StructureGenerationModel } from "../../../model-function/generate-structure/StructureGenerationModel.js";
 import { StructureOrTextGenerationModel } from "../../../model-function/generate-structure/StructureOrTextGenerationModel.js";
-import { TextGenerationModel, TextGenerationModelSettings } from "../../../model-function/generate-text/TextGenerationModel.js";
+import { TextGenerationModelSettings, TextStreamingModel } from "../../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../../prompt/PromptFormat.js";
-import { PromptFormatTextGenerationModel } from "../../../prompt/PromptFormatTextGenerationModel.js";
+import { PromptFormatTextStreamingModel } from "../../../prompt/PromptFormatTextStreamingModel.js";
 import { TikTokenTokenizer } from "../TikTokenTokenizer.js";
 import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
-import { OpenAIChatDelta } from "./OpenAIChatStreamIterable.js";
 export declare const OPENAI_CHAT_MODELS: {
     "gpt-4": {
         contextWindowSize: number;
@@ -132,7 +131,7 @@ export interface OpenAIChatSettings extends TextGenerationModelSettings, Omit<Op
  *   ),
  * ]);
  */
-export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, StructureGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, StructureOrTextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatSettings> {
+export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextStreamingModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureGenerationModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureOrTextGenerationModel<OpenAIChatMessage[], OpenAIChatSettings> {
     constructor(settings: OpenAIChatSettings);
     readonly provider: "openai";
     get modelName(): OpenAIChatModelType;
@@ -145,37 +144,50 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
     countPromptTokens(messages: OpenAIChatMessage[]): Promise<number>;
     callAPI<RESULT>(messages: Array<OpenAIChatMessage>, options: {
         responseFormat: OpenAIChatResponseFormatType<RESULT>;
-    } & ModelFunctionOptions<Partial<OpenAIChatCallSettings & {
-        user?: string;
-    }>>): Promise<RESULT>;
+    } & FunctionOptions & {
+        functions?: Array<{
+            name: string;
+            description?: string;
+            parameters: unknown;
+        }>;
+        functionCall?: "none" | "auto" | {
+            name: string;
+        };
+    }): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAIChatSettings>;
-    generateTextResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<{
-        object: "chat.completion";
-        model: string;
+    doGenerateText(prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "chat.completion";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            id: string;
+            created: number;
+            choices: {
+                message: {
+                    content: string | null;
+                    role: "assistant";
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                };
+                finish_reason: string;
+                index: number;
+                logprobs?: any;
+            }[];
+        };
+        text: string;
         usage: {
-            prompt_tokens: number;
-            completion_tokens: number;
-            total_tokens: number;
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
         };
-        id: string;
-        created: number;
-        choices: {
-            message: {
-                content: string | null;
-                role: "assistant";
-                function_call?: {
-                    name: string;
-                    arguments: string;
-                } | undefined;
-            };
-            finish_reason: string;
-            index: number;
-            logprobs?: any;
-        }[];
     }>;
-    extractText(response: OpenAIChatResponse): string;
-    generateDeltaStreamResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
-    extractTextDelta(fullDelta: OpenAIChatDelta): string | undefined;
+    doStreamText(prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
     /**
      * JSON generation uses the OpenAI GPT function calling API.
      * It provides a single function specification and instructs the model to provide parameters for calling the function.
@@ -183,26 +195,85 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
      *
      * @see https://platform.openai.com/docs/guides/gpt/function-calling
      */
-    generateStructureResponse(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
-    extractStructure(response: OpenAIChatResponse): unknown;
-    generateStructureStreamResponse(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
-    extractPartialStructure(fullDelta: OpenAIChatDelta): unknown | undefined;
-    generateStructureOrTextResponse(structureDefinitions: Array<StructureDefinition<string, unknown>>, prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
-    extractStructureAndText(response: OpenAIChatResponse): {
-        structure: null;
-        value: null;
-        text: string;
-    } | {
-        structure: string;
-        value: any;
-        text: string | null;
-    };
+    doGenerateStructure(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "chat.completion";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            id: string;
+            created: number;
+            choices: {
+                message: {
+                    content: string | null;
+                    role: "assistant";
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                };
+                finish_reason: string;
+                index: number;
+                logprobs?: any;
+            }[];
+        };
+        structure: any;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+    doStreamStructure(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<AsyncIterable<Delta<unknown>>>;
+    doGenerateStructureOrText(structureDefinitions: Array<StructureDefinition<string, unknown>>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "chat.completion";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            id: string;
+            created: number;
+            choices: {
+                message: {
+                    content: string | null;
+                    role: "assistant";
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                };
+                finish_reason: string;
+                index: number;
+                logprobs?: any;
+            }[];
+        };
+        structureAndText: {
+            structure: null;
+            value: null;
+            text: string;
+        } | {
+            structure: string;
+            value: any;
+            text: string | null;
+        };
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
     extractUsage(response: OpenAIChatResponse): {
         promptTokens: number;
         completionTokens: number;
         totalTokens: number;
     };
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): PromptFormatTextGenerationModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings, this>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): PromptFormatTextStreamingModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatSettings, this>;
     withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;
 }
 declare const openAIChatResponseSchema: z.ZodObject<{
@@ -366,11 +437,17 @@ export declare const OpenAIChatResponseFormat: {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    deltaIterable: {
+    textDeltaIterable: {
+        stream: true;
+        handler: ({ response }: {
+            response: Response;
+        }) => Promise<AsyncIterable<Delta<string>>>;
+    };
+    structureDeltaIterable: {
         stream: true;
         handler: ({ response }: {
             response: Response;
-        }) => Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
+        }) => Promise<AsyncIterable<Delta<unknown>>>;
     };
 };
 export {};