modelfusion 0.80.0 → 0.82.0

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

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIChatFunctionCallStructureGenerationModel = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const StructureParseError_js_1 = require("../../../model-function/generate-structure/StructureParseError.cjs");
+const OpenAIChatModel_1 = require("./OpenAIChatModel");
+const OpenAIChatPromptFormat_js_1 = require("./OpenAIChatPromptFormat.cjs");
+class OpenAIChatFunctionCallStructureGenerationModel {
+    constructor({ model, fnName, fnDescription, promptFormat, }) {
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fnName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fnDescription", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "promptFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = model;
+        this.fnName = fnName;
+        this.fnDescription = fnDescription;
+        this.promptFormat = promptFormat;
+    }
+    get modelInformation() {
+        return this.model.modelInformation;
+    }
+    get settings() {
+        return this.model.settings;
+    }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
+    /**
+     * Returns this model with a text prompt format.
+     */
+    withTextPrompt() {
+        return this.withPromptFormat((0, OpenAIChatPromptFormat_js_1.text)());
+    }
+    /**
+     * Returns this model with an instruction prompt format.
+     */
+    withInstructionPrompt() {
+        return this.withPromptFormat((0, OpenAIChatPromptFormat_js_1.instruction)());
+    }
+    /**
+     * Returns this model with a chat prompt format.
+     */
+    withChatPrompt() {
+        return this.withPromptFormat((0, OpenAIChatPromptFormat_js_1.chat)());
+    }
+    withPromptFormat(promptFormat) {
+        return new OpenAIChatFunctionCallStructureGenerationModel({
+            model: this.model,
+            fnName: this.fnName,
+            fnDescription: this.fnDescription,
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OpenAIChatFunctionCallStructureGenerationModel({
+            model: this.model.withSettings(additionalSettings),
+            fnName: this.fnName,
+            fnDescription: this.fnDescription,
+            promptFormat: this.promptFormat,
+        });
+    }
+    /**
+     * 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.
+     * The result is returned as parsed JSON.
+     *
+     * @see https://platform.openai.com/docs/guides/gpt/function-calling
+     */
+    async doGenerateStructure(schema, prompt, // first argument of the function
+    options) {
+        const expandedPrompt = this.promptFormat.format(prompt);
+        const response = await this.model
+            .withSettings({
+            stopSequences: [
+                ...(this.settings.stopSequences ?? []),
+                ...this.promptFormat.stopSequences,
+            ],
+        })
+            .callAPI(expandedPrompt, {
+            ...options,
+            responseFormat: OpenAIChatModel_1.OpenAIChatResponseFormat.json,
+            functionCall: { name: this.fnName },
+            functions: [
+                {
+                    name: this.fnName,
+                    description: this.fnDescription,
+                    parameters: schema.getJsonSchema(),
+                },
+            ],
+        });
+        const valueText = response.choices[0].message.function_call.arguments;
+        try {
+            return {
+                response,
+                valueText,
+                value: secure_json_parse_1.default.parse(valueText),
+                usage: this.model.extractUsage(response),
+            };
+        }
+        catch (error) {
+            throw new StructureParseError_js_1.StructureParseError({
+                valueText,
+                cause: error,
+            });
+        }
+    }
+    async doStreamStructure(schema, prompt, // first argument of the function
+    options) {
+        const expandedPrompt = this.promptFormat.format(prompt);
+        return this.model.callAPI(expandedPrompt, {
+            ...options,
+            responseFormat: OpenAIChatModel_1.OpenAIChatResponseFormat.structureDeltaIterable,
+            functionCall: { name: this.fnName },
+            functions: [
+                {
+                    name: this.fnName,
+                    description: this.fnDescription,
+                    parameters: schema.getJsonSchema(),
+                },
+            ],
+        });
+    }
+}
+exports.OpenAIChatFunctionCallStructureGenerationModel = OpenAIChatFunctionCallStructureGenerationModel;

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

@@ -0,0 +1,89 @@
+import { FunctionOptions } from "../../../core/FunctionOptions.js";
+import { JsonSchemaProducer } from "../../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../../core/schema/Schema.js";
+import { StructureGenerationModel } from "../../../model-function/generate-structure/StructureGenerationModel.js";
+import { TextGenerationPromptFormat } from "../../../model-function/generate-text/TextGenerationPromptFormat.js";
+import { OpenAIChatMessage } from "./OpenAIChatMessage";
+import { OpenAIChatModel, OpenAIChatSettings } from "./OpenAIChatModel";
+export declare class OpenAIChatFunctionCallStructureGenerationModel<PROMPT_FORMAT extends TextGenerationPromptFormat<unknown, OpenAIChatMessage[]>> implements StructureGenerationModel<Parameters<PROMPT_FORMAT["format"]>[0], // first argument of the function
+OpenAIChatSettings> {
+    readonly model: OpenAIChatModel;
+    readonly fnName: string;
+    readonly fnDescription?: string;
+    readonly promptFormat: PROMPT_FORMAT;
+    constructor({ model, fnName, fnDescription, promptFormat, }: {
+        model: OpenAIChatModel;
+        fnName: string;
+        fnDescription?: string;
+        promptFormat: PROMPT_FORMAT;
+    });
+    get modelInformation(): import("../../../index.js").ModelInformation;
+    get settings(): OpenAIChatSettings;
+    get settingsForEvent(): Partial<OpenAIChatSettings>;
+    /**
+     * Returns this model with a text prompt format.
+     */
+    withTextPrompt(): OpenAIChatFunctionCallStructureGenerationModel<TextGenerationPromptFormat<string, OpenAIChatMessage[]>>;
+    /**
+     * Returns this model with an instruction prompt format.
+     */
+    withInstructionPrompt(): OpenAIChatFunctionCallStructureGenerationModel<TextGenerationPromptFormat<import("../../../index.js").InstructionPrompt | import("../../../index.js").TextInstructionPrompt, OpenAIChatMessage[]>>;
+    /**
+     * Returns this model with a chat prompt format.
+     */
+    withChatPrompt(): OpenAIChatFunctionCallStructureGenerationModel<TextGenerationPromptFormat<import("../../../index.js").ChatPrompt, OpenAIChatMessage[]>>;
+    withPromptFormat<TARGET_PROMPT_FORMAT extends TextGenerationPromptFormat<unknown, OpenAIChatMessage[]>>(promptFormat: TARGET_PROMPT_FORMAT): OpenAIChatFunctionCallStructureGenerationModel<TARGET_PROMPT_FORMAT>;
+    withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;
+    /**
+     * 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.
+     * The result is returned as parsed JSON.
+     *
+     * @see https://platform.openai.com/docs/guides/gpt/function-calling
+     */
+    doGenerateStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: Parameters<PROMPT_FORMAT["format"]>[0], // first argument of the function
+    options?: FunctionOptions): Promise<{
+        response: {
+            object: "chat.completion";
+            usage: {
+                prompt_tokens: number;
+                total_tokens: number;
+                completion_tokens: number;
+            };
+            model: string;
+            id: string;
+            choices: {
+                message: {
+                    role: "assistant";
+                    content: string | null;
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
+                };
+                index: number;
+                logprobs?: any;
+                finish_reason?: "length" | "stop" | "tool_calls" | "function_call" | "content_filter" | null | undefined;
+            }[];
+            created: number;
+            system_fingerprint?: string | undefined;
+        };
+        valueText: string;
+        value: any;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+    doStreamStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: Parameters<PROMPT_FORMAT["format"]>[0], // first argument of the function
+    options?: FunctionOptions): Promise<AsyncIterable<import("../../../index.js").Delta<unknown>>>;
+}

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

@@ -0,0 +1,140 @@
+import SecureJSON from "secure-json-parse";
+import { StructureParseError } from "../../../model-function/generate-structure/StructureParseError.js";
+import { OpenAIChatResponseFormat, } from "./OpenAIChatModel";
+import { chat, instruction, text } from "./OpenAIChatPromptFormat.js";
+export class OpenAIChatFunctionCallStructureGenerationModel {
+    constructor({ model, fnName, fnDescription, promptFormat, }) {
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fnName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fnDescription", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "promptFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = model;
+        this.fnName = fnName;
+        this.fnDescription = fnDescription;
+        this.promptFormat = promptFormat;
+    }
+    get modelInformation() {
+        return this.model.modelInformation;
+    }
+    get settings() {
+        return this.model.settings;
+    }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
+    /**
+     * Returns this model with a text prompt format.
+     */
+    withTextPrompt() {
+        return this.withPromptFormat(text());
+    }
+    /**
+     * Returns this model with an instruction prompt format.
+     */
+    withInstructionPrompt() {
+        return this.withPromptFormat(instruction());
+    }
+    /**
+     * Returns this model with a chat prompt format.
+     */
+    withChatPrompt() {
+        return this.withPromptFormat(chat());
+    }
+    withPromptFormat(promptFormat) {
+        return new OpenAIChatFunctionCallStructureGenerationModel({
+            model: this.model,
+            fnName: this.fnName,
+            fnDescription: this.fnDescription,
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OpenAIChatFunctionCallStructureGenerationModel({
+            model: this.model.withSettings(additionalSettings),
+            fnName: this.fnName,
+            fnDescription: this.fnDescription,
+            promptFormat: this.promptFormat,
+        });
+    }
+    /**
+     * 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.
+     * The result is returned as parsed JSON.
+     *
+     * @see https://platform.openai.com/docs/guides/gpt/function-calling
+     */
+    async doGenerateStructure(schema, prompt, // first argument of the function
+    options) {
+        const expandedPrompt = this.promptFormat.format(prompt);
+        const response = await this.model
+            .withSettings({
+            stopSequences: [
+                ...(this.settings.stopSequences ?? []),
+                ...this.promptFormat.stopSequences,
+            ],
+        })
+            .callAPI(expandedPrompt, {
+            ...options,
+            responseFormat: OpenAIChatResponseFormat.json,
+            functionCall: { name: this.fnName },
+            functions: [
+                {
+                    name: this.fnName,
+                    description: this.fnDescription,
+                    parameters: schema.getJsonSchema(),
+                },
+            ],
+        });
+        const valueText = response.choices[0].message.function_call.arguments;
+        try {
+            return {
+                response,
+                valueText,
+                value: SecureJSON.parse(valueText),
+                usage: this.model.extractUsage(response),
+            };
+        }
+        catch (error) {
+            throw new StructureParseError({
+                valueText,
+                cause: error,
+            });
+        }
+    }
+    async doStreamStructure(schema, prompt, // first argument of the function
+    options) {
+        const expandedPrompt = this.promptFormat.format(prompt);
+        return this.model.callAPI(expandedPrompt, {
+            ...options,
+            responseFormat: OpenAIChatResponseFormat.structureDeltaIterable,
+            functionCall: { name: this.fnName },
+            functions: [
+                {
+                    name: this.fnName,
+                    description: this.fnDescription,
+                    parameters: schema.getJsonSchema(),
+                },
+            ],
+        });
+    }
+}

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

@@ -1,21 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIChatResponseFormat = exports.OpenAIChatModel = exports.calculateOpenAIChatCostInMillicents = exports.isOpenAIChatModel = exports.getOpenAIChatModelInformation = exports.OPENAI_CHAT_MODELS = void 0;
-const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../../core/api/postToApi.cjs");
 const parseJSON_js_1 = require("../../../core/schema/parseJSON.cjs");
 const AbstractModel_js_1 = require("../../../model-function/AbstractModel.cjs");
-const StructureParseError_js_1 = require("../../../model-function/generate-structure/StructureParseError.cjs");
+const StructureFromTextStreamingModel_js_1 = require("../../../model-function/generate-structure/StructureFromTextStreamingModel.cjs");
 const parsePartialJson_js_1 = require("../../../model-function/generate-structure/parsePartialJson.cjs");
 const PromptFormatTextStreamingModel_js_1 = require("../../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");
 const OpenAIApiConfiguration_js_1 = require("../OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("../OpenAIError.cjs");
 const TikTokenTokenizer_js_1 = require("../TikTokenTokenizer.cjs");
+const OpenAIChatFunctionCallStructureGenerationModel_js_1 = require("./OpenAIChatFunctionCallStructureGenerationModel.cjs");
 const OpenAIChatPromptFormat_js_1 = require("./OpenAIChatPromptFormat.cjs");
 const OpenAIChatStreamIterable_js_1 = require("./OpenAIChatStreamIterable.cjs");
 const countOpenAIChatMessageTokens_js_1 = require("./countOpenAIChatMessageTokens.cjs");
@@ -264,57 +261,6 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
             responseFormat: exports.OpenAIChatResponseFormat.textDeltaIterable,
         });
     }
-    /**
-     * 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.
-     * The result is returned as parsed JSON.
-     *
-     * @see https://platform.openai.com/docs/guides/gpt/function-calling
-     */
-    async doGenerateStructure(structureDefinition, prompt, options) {
-        const response = await this.callAPI(prompt, {
-            ...options,
-            responseFormat: exports.OpenAIChatResponseFormat.json,
-            functionCall: { name: structureDefinition.name },
-            functions: [
-                {
-                    name: structureDefinition.name,
-                    description: structureDefinition.description,
-                    parameters: structureDefinition.schema.getJsonSchema(),
-                },
-            ],
-        });
-        const valueText = response.choices[0].message.function_call.arguments;
-        try {
-            return {
-                response,
-                valueText,
-                value: secure_json_parse_1.default.parse(valueText),
-                usage: this.extractUsage(response),
-            };
-        }
-        catch (error) {
-            throw new StructureParseError_js_1.StructureParseError({
-                structureName: structureDefinition.name,
-                valueText,
-                cause: error,
-            });
-        }
-    }
-    async doStreamStructure(structureDefinition, prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
-            responseFormat: exports.OpenAIChatResponseFormat.structureDeltaIterable,
-            functionCall: { name: structureDefinition.name },
-            functions: [
-                {
-                    name: structureDefinition.name,
-                    description: structureDefinition.description,
-                    parameters: structureDefinition.schema.getJsonSchema(),
-                },
-            ],
-        });
-    }
     async doGenerateToolCall(tool, prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
@@ -379,6 +325,20 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
             totalTokens: response.usage.total_tokens,
         };
     }
+    asFunctionCallStructureGenerationModel({ fnName, fnDescription, }) {
+        return new OpenAIChatFunctionCallStructureGenerationModel_js_1.OpenAIChatFunctionCallStructureGenerationModel({
+            model: this,
+            fnName,
+            fnDescription,
+            promptFormat: (0, OpenAIChatPromptFormat_js_1.identity)(),
+        });
+    }
+    asStructureGenerationModel(promptFormat) {
+        return new StructureFromTextStreamingModel_js_1.StructureFromTextStreamingModel({
+            model: this,
+            format: promptFormat,
+        });
+    }
     /**
      * Returns this model with a text prompt format.
      */

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

@@ -2,10 +2,10 @@ 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/schema/StructureDefinition.js";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
 import { Delta } from "../../../model-function/Delta.js";
-import { StructureGenerationModel } from "../../../model-function/generate-structure/StructureGenerationModel.js";
+import { StructureFromTextPromptFormat } from "../../../model-function/generate-structure/StructureFromTextPromptFormat.js";
+import { StructureFromTextStreamingModel } from "../../../model-function/generate-structure/StructureFromTextStreamingModel.js";
 import { PromptFormatTextStreamingModel } from "../../../model-function/generate-text/PromptFormatTextStreamingModel.js";
 import { TextGenerationModelSettings, TextStreamingModel } from "../../../model-function/generate-text/TextGenerationModel.js";
 import { TextGenerationPromptFormat } from "../../../model-function/generate-text/TextGenerationPromptFormat.js";
@@ -13,6 +13,7 @@ import { ToolDefinition } from "../../../tool/ToolDefinition.js";
 import { ToolCallGenerationModel } from "../../../tool/generate-tool-call/ToolCallGenerationModel.js";
 import { ToolCallsOrTextGenerationModel } from "../../../tool/generate-tool-calls-or-text/ToolCallsOrTextGenerationModel.js";
 import { TikTokenTokenizer } from "../TikTokenTokenizer.js";
+import { OpenAIChatFunctionCallStructureGenerationModel } from "./OpenAIChatFunctionCallStructureGenerationModel.js";
 import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
 export declare const OPENAI_CHAT_MODELS: {
     "gpt-4": {
@@ -168,7 +169,7 @@ export interface OpenAIChatSettings extends TextGenerationModelSettings, Omit<Op
  *   ),
  * ]);
  */
-export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextStreamingModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureGenerationModel<OpenAIChatMessage[], OpenAIChatSettings>, ToolCallGenerationModel<OpenAIChatMessage[], OpenAIChatSettings>, ToolCallsOrTextGenerationModel<OpenAIChatMessage[], OpenAIChatSettings> {
+export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextStreamingModel<OpenAIChatMessage[], OpenAIChatSettings>, ToolCallGenerationModel<OpenAIChatMessage[], OpenAIChatSettings>, ToolCallsOrTextGenerationModel<OpenAIChatMessage[], OpenAIChatSettings> {
     constructor(settings: OpenAIChatSettings);
     readonly provider: "openai";
     get modelName(): OpenAIChatModelType;
@@ -230,56 +231,6 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
         };
     }>;
     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.
-     * The result is returned as parsed JSON.
-     *
-     * @see https://platform.openai.com/docs/guides/gpt/function-calling
-     */
-    doGenerateStructure(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
-        response: {
-            object: "chat.completion";
-            usage: {
-                prompt_tokens: number;
-                total_tokens: number;
-                completion_tokens: number;
-            };
-            model: string;
-            id: string;
-            choices: {
-                message: {
-                    role: "assistant";
-                    content: string | null;
-                    function_call?: {
-                        name: string;
-                        arguments: string;
-                    } | undefined;
-                    tool_calls?: {
-                        function: {
-                            name: string;
-                            arguments: string;
-                        };
-                        type: "function";
-                        id: string;
-                    }[] | undefined;
-                };
-                index: number;
-                logprobs?: any;
-                finish_reason?: "length" | "stop" | "tool_calls" | "function_call" | "content_filter" | null | undefined;
-            }[];
-            created: number;
-            system_fingerprint?: string | undefined;
-        };
-        valueText: string;
-        value: any;
-        usage: {
-            promptTokens: number;
-            completionTokens: number;
-            totalTokens: number;
-        };
-    }>;
-    doStreamStructure(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<AsyncIterable<Delta<unknown>>>;
     doGenerateToolCall(tool: ToolDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
         response: {
             object: "chat.completion";
@@ -375,6 +326,11 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
         completionTokens: number;
         totalTokens: number;
     };
+    asFunctionCallStructureGenerationModel({ fnName, fnDescription, }: {
+        fnName: string;
+        fnDescription?: string;
+    }): OpenAIChatFunctionCallStructureGenerationModel<TextGenerationPromptFormat<OpenAIChatMessage[], OpenAIChatMessage[]>>;
+    asStructureGenerationModel<INPUT_PROMPT>(promptFormat: StructureFromTextPromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): StructureFromTextStreamingModel<INPUT_PROMPT, OpenAIChatMessage[], this>;
     /**
      * Returns this model with a text prompt format.
      */

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

@@ -1,16 +1,16 @@
-import SecureJSON from "secure-json-parse";
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../../core/api/postToApi.js";
 import { parseJSON } from "../../../core/schema/parseJSON.js";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
-import { StructureParseError } from "../../../model-function/generate-structure/StructureParseError.js";
+import { StructureFromTextStreamingModel } from "../../../model-function/generate-structure/StructureFromTextStreamingModel.js";
 import { parsePartialJson } from "../../../model-function/generate-structure/parsePartialJson.js";
 import { PromptFormatTextStreamingModel } from "../../../model-function/generate-text/PromptFormatTextStreamingModel.js";
 import { OpenAIApiConfiguration } from "../OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "../OpenAIError.js";
 import { TikTokenTokenizer } from "../TikTokenTokenizer.js";
-import { chat, instruction, text } from "./OpenAIChatPromptFormat.js";
+import { OpenAIChatFunctionCallStructureGenerationModel } from "./OpenAIChatFunctionCallStructureGenerationModel.js";
+import { chat, identity, instruction, text } from "./OpenAIChatPromptFormat.js";
 import { createOpenAIChatDeltaIterableQueue } from "./OpenAIChatStreamIterable.js";
 import { countOpenAIChatPromptTokens } from "./countOpenAIChatMessageTokens.js";
 /*
@@ -255,57 +255,6 @@ export class OpenAIChatModel extends AbstractModel {
             responseFormat: OpenAIChatResponseFormat.textDeltaIterable,
         });
     }
-    /**
-     * 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.
-     * The result is returned as parsed JSON.
-     *
-     * @see https://platform.openai.com/docs/guides/gpt/function-calling
-     */
-    async doGenerateStructure(structureDefinition, prompt, options) {
-        const response = await this.callAPI(prompt, {
-            ...options,
-            responseFormat: OpenAIChatResponseFormat.json,
-            functionCall: { name: structureDefinition.name },
-            functions: [
-                {
-                    name: structureDefinition.name,
-                    description: structureDefinition.description,
-                    parameters: structureDefinition.schema.getJsonSchema(),
-                },
-            ],
-        });
-        const valueText = response.choices[0].message.function_call.arguments;
-        try {
-            return {
-                response,
-                valueText,
-                value: SecureJSON.parse(valueText),
-                usage: this.extractUsage(response),
-            };
-        }
-        catch (error) {
-            throw new StructureParseError({
-                structureName: structureDefinition.name,
-                valueText,
-                cause: error,
-            });
-        }
-    }
-    async doStreamStructure(structureDefinition, prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
-            responseFormat: OpenAIChatResponseFormat.structureDeltaIterable,
-            functionCall: { name: structureDefinition.name },
-            functions: [
-                {
-                    name: structureDefinition.name,
-                    description: structureDefinition.description,
-                    parameters: structureDefinition.schema.getJsonSchema(),
-                },
-            ],
-        });
-    }
     async doGenerateToolCall(tool, prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
@@ -370,6 +319,20 @@ export class OpenAIChatModel extends AbstractModel {
             totalTokens: response.usage.total_tokens,
         };
     }
+    asFunctionCallStructureGenerationModel({ fnName, fnDescription, }) {
+        return new OpenAIChatFunctionCallStructureGenerationModel({
+            model: this,
+            fnName,
+            fnDescription,
+            promptFormat: identity(),
+        });
+    }
+    asStructureGenerationModel(promptFormat) {
+        return new StructureFromTextStreamingModel({
+            model: this,
+            format: promptFormat,
+        });
+    }
     /**
      * Returns this model with a text prompt format.
      */