modelfusion 0.111.0 → 0.113.0

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # Changelog
 
+## v0.113.0 - 2024-01-03
+
+[Structure generation](https://modelfusion.dev/guide/function/generate-structure) improvements.
+
+### Added
+
+- `.asStructureGenerationModel(...)` function to `OpenAIChatModel` and `OllamaChatModel` to create structure generation models from chat models.
+- `jsonStructurePrompt` helper function to create structure generation models.
+
+### Example
+
+```ts
+import {
+  generateStructure,
+  jsonStructurePrompt,
+  ollama,
+  zodSchema,
+} from "modelfusion";
+
+const structure = await generateStructure(
+  ollama
+    .ChatTextGenerator({
+      model: "openhermes2.5-mistral",
+      maxGenerationTokens: 1024,
+      temperature: 0,
+    })
+    .asStructureGenerationModel(jsonStructurePrompt.text()),
+
+  zodSchema(
+    z.object({
+      characters: z.array(
+        z.object({
+          name: z.string(),
+          class: z
+            .string()
+            .describe("Character class, e.g. warrior, mage, or thief."),
+          description: z.string(),
+        })
+      ),
+    })
+  ),
+
+  "Generate 3 character descriptions for a fantasy role playing game. "
+);
+```
+
+## v0.112.0 - 2024-01-02
+
+### Changed
+
+- **breaking change**: renamed `useToolsOrGenerateText` to `useTools`
+- **breaking change**: renamed `generateToolCallsOrText` to `generateToolCalls`
+
+### Removed
+
+- Restriction on tool names. OpenAI tool calls do not have such a restriction.
+
 ## v0.111.0 - 2024-01-01
 
 Reworked API configuration support.

package/README.md

@@ -1,6 +1,6 @@
 # ModelFusion
 
-> ### The TypeScript library for building multi-modal AI applications.
+> ### The TypeScript library for building sAI applications.
 
 [![NPM Version](https://img.shields.io/npm/v/modelfusion?color=33cd56&logo=npm)](https://www.npmjs.com/package/modelfusion)
 [![MIT License](https://img.shields.io/github/license/lgrammel/modelfusion)](https://opensource.org/licenses/MIT)
@@ -12,7 +12,7 @@
 
 ## Introduction
 
-**ModelFusion** is an abstraction layer for integrating AI models into JavaScript and TypeScript applications, unifying the API for common operations such as text streaming, structure generation, and tool usage. It provides features to support production environments, including observability hooks, logging, and automatic retries. You can use ModelFusion to build AI applications, chatbots, and agents.
+**ModelFusion** is an abstraction layer for integrating AI models into JavaScript and TypeScript applications, unifying the API for common operations such as **text streaming**, **structure generation**, and **tool usage**. It provides features to support production environments, including observability hooks, logging, and automatic retries. You can use ModelFusion to build AI applications, chatbots, and agents.
 
 - **Vendor-neutral**: ModelFusion is a non-commercial open source project that is community-driven. You can use it with any supported provider.
 - **Multi-modal**: ModelFusion supports a wide range of models including text generation, image generation, vision, text-to-speech, speech-to-text, and embedding models.
@@ -201,18 +201,22 @@ Generate typed objects using a language model and a schema.
 Generate a structure that matches a schema.
 
 ```ts
-import { zodSchema, generateStructure, openai } from "modelfusion";
+import {
+  ollama,
+  zodSchema,
+  generateStructure,
+  jsonStructurePrompt,
+} from "modelfusion";
 
 const sentiment = await generateStructure(
   // model:
-  openai
+  ollama
     .ChatTextGenerator({
-      model: "gpt-3.5-turbo",
+      model: "openhermes2.5-mistral",
+      maxGenerationTokens: 1024,
       temperature: 0,
-      maxGenerationTokens: 50,
     })
-    .asFunctionCallStructureGenerationModel({ fnName: "sentiment" })
-    .withInstructionPrompt(),
+    .asStructureGenerationModel(jsonStructurePrompt.instruction()),
 
   // schema:
   zodSchema(
@@ -326,85 +330,13 @@ Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai),
 
 ### [Tools](https://modelfusion.dev/guide/tools)
 
-Tools are functions that can be executed by an AI model. They are useful for building chatbots and agents.
-
-Predefined tools: [Math.js](https://modelfusion.dev/guide/tools/predefined-tools/mathjs), [SerpAPI](https://modelfusion.dev/guide/tools/predefined-tools/serpapi), [Google Custom Search](https://modelfusion.dev/guide/tools/predefined-tools/google-custom-search)
-
-#### [Creating Tools](https://modelfusion.dev/guide/tools/create-tools)
-
-A tool is comprised of an async execute function, a name, a description, and a schema for the input parameters.
-
-```ts
-const calculator = new Tool({
-  name: "calculator",
-  description: "Execute a calculation",
-
-  parameters: zodSchema(
-    z.object({
-      a: z.number().describe("The first number."),
-      b: z.number().describe("The second number."),
-      operator: z
-        .enum(["+", "-", "*", "/"])
-        .describe("The operator (+, -, *, /)."),
-    })
-  ),
-
-  execute: async ({ a, b, operator }) => {
-    switch (operator) {
-      case "+":
-        return a + b;
-      case "-":
-        return a - b;
-      case "*":
-        return a * b;
-      case "/":
-        return a / b;
-      default:
-        throw new Error(`Unknown operator: ${operator}`);
-    }
-  },
-});
-```
+Tools are functions (and associated metadata) that can be executed by an AI model. They are useful for building chatbots and agents.
 
-#### [generateToolCall](https://modelfusion.dev/guide/tools/generate-tool-call)
-
-With `generateToolCall`, you can generate a tool call for a specific tool with a language model that supports tools calls (e.g. OpenAI Chat). This function does not execute the tools.
-
-```ts
-const { id, name, args } = await generateToolCall(
-  openai.ChatTextGenerator({ model: "gpt-3.5-turbo" }),
-  calculator,
-  [openai.ChatMessage.user("What's fourteen times twelve?")]
-);
-```
-
-#### [generateToolCallsOrText](https://modelfusion.dev/guide/tools/generate-tool-calls-or-text)
-
-With `generateToolCallsOrText`, you can ask a language model to generate several tool calls as well as text. The model will choose which tools (if any) should be called with which arguments. Both the text and the tool calls are optional. This function does not execute the tools.
-
-```ts
-const { text, toolCalls } = await generateToolCallsOrText(
-  openai.ChatTextGenerator({ model: "gpt-3.5-turbo" }),
-  [toolA, toolB, toolC],
-  [openai.ChatMessage.user(query)]
-);
-```
-
-#### [executeTool](https://modelfusion.dev/guide/tools/execute-tool)
-
-You can directly invoke a tool with `executeTool`:
-
-```ts
-const result = await executeTool(calculator, {
-  a: 14,
-  b: 12,
-  operator: "*",
-});
-```
+ModelFusion offers several tools out-of-the-box: [Math.js](https://modelfusion.dev/guide/tools/available-tools/mathjs), [MediaWiki Search](https://modelfusion.dev/guide/tools/available-tools/mediawiki-search), [SerpAPI](https://modelfusion.dev/guide/tools/available-tools/serpapi), [Google Custom Search](https://modelfusion.dev/guide/tools/available-tools/google-custom-search). You can also create [custom tools](https://modelfusion.dev/guide/tools).
 
 #### [useTool](https://modelfusion.dev/guide/tools/use-tool)
 
-With `useTool`, you can use a tool with a language model that supports tools calls (e.g. OpenAI Chat). `useTool` first generates a tool call and then executes the tool with the arguments.
+With `useTool`, you can ask a tool-compatible language model (e.g. OpenAI chat) to invoke a single tool. `useTool` first generates a tool call and then executes the tool with the arguments.
 
 ```ts
 const { tool, toolCall, args, ok, result } = await useTool(
@@ -420,12 +352,12 @@ console.log(`Ok:`, ok);
 console.log(`Result or Error:`, result);
 ```
 
-#### [useToolsOrGenerateText](https://modelfusion.dev/guide/tools/use-tools-or-generate-text)
+#### [useTools](https://modelfusion.dev/guide/tools/use-tools)
 
-With `useToolsOrGenerateText`, you can ask a language model to generate several tool calls as well as text. The model will choose which tools (if any) should be called with which arguments. Both the text and the tool calls are optional. This function executes the tools.
+With `useTools`, you can ask a language model to generate several tool calls as well as text. The model will choose which tools (if any) should be called with which arguments. Both the text and the tool calls are optional. This function executes the tools.
 
 ```ts
-const { text, toolResults } = await useToolsOrGenerateText(
+const { text, toolResults } = await useTools(
   openai.ChatTextGenerator({ model: "gpt-3.5-turbo" }),
   [calculator /* ... */],
   [openai.ChatMessage.user("What's fourteen times twelve?")]
@@ -434,7 +366,7 @@ const { text, toolResults } = await useToolsOrGenerateText(
 
 #### [Agent Loop](https://modelfusion.dev/guide/tools/agent-loop)
 
-You can use `useToolsOrGenerateText` to implement an agent loop that responds to user messages and executes tools. [Learn more](https://modelfusion.dev/guide/tools/agent-loop).
+You can use `useTools` to implement an agent loop that responds to user messages and executes tools. [Learn more](https://modelfusion.dev/guide/tools/agent-loop).
 
 ### [Vector Indices](https://modelfusion.dev/guide/vector-index)
 
@@ -606,85 +538,25 @@ import { modelfusion } from "modelfusion";
 modelfusion.setLogFormat("detailed-object"); // log full events
 ```
 
-### [Server](https://modelfusion.dev/guide/experimental/server/)
-
-> [!WARNING]
-> ModelFusion Server is in its initial development phase and not feature-complete. The API is experimental and breaking changes are likely. Feedback and suggestions are welcome.
-
-ModelFusion Server is desigend for running multi-modal generative AI flows that take up to several minutes to complete. It provides the following benefits:
-
-- 🔄 Real-time progress updates via custom server-sent events
-- 🔒Type-safety with Zod-schema for inputs/events
-- 📦 Efficient handling of dynamically created binary assets (images, audio)
-- 📜 Auto-logging for AI model interactions within flows
-
-ModelFusion provides a [Fastify](https://fastify.dev/) plugin that allows you to set up a server that exposes your ModelFusion flows as REST endpoints using server-sent events.
-
-```ts
-import {
-  FileSystemAssetStorage,
-  FileSystemLogger,
-  modelFusionFastifyPlugin,
-} from "modelfusion-experimental/fastify-server"; // '/fastify-server' import path
-
-// configurable logging for all runs using ModelFusion observability:
-const logger = new FileSystemLogger({
-  path: (run) => path.join(fsBasePath, run.runId, "logs"),
-});
-
-// configurable storage for large files like images and audio files:
-const assetStorage = new FileSystemAssetStorage({
-  path: (run) => path.join(fsBasePath, run.runId, "assets"),
-  logger,
-});
-
-fastify.register(modelFusionFastifyPlugin, {
-  baseUrl,
-  basePath: "/myFlow",
-  logger,
-  assetStorage,
-  flow: exampleFlow,
-});
-```
-
-Using `invokeFlow`, you can easily connect your client to a ModelFusion flow endpoint:
-
-```ts
-import { invokeFlow } from "modelfusion-experimental/browser"; // '/browser' import path
-
-invokeFlow({
-  url: `${BASE_URL}/myFlow`,
-  schema: myFlowSchema,
-  input: { prompt },
-  onEvent(event) {
-    switch (event.type) {
-      case "my-event": {
-        // do something with the event
-        break;
-      }
-      // more events...
-    }
-  },
-  onStop() {
-    // flow finished
-  },
-});
-```
-
 ## Documentation
 
 ### [Guide](https://modelfusion.dev/guide)
 
 - [Model Functions](https://modelfusion.dev/guide/function/)
   - [Generate text](https://modelfusion.dev/guide/function/generate-text)
+  - [Generate structure](https://modelfusion.dev/guide/function/generate-structure)
   - [Generate image](https://modelfusion.dev/guide/function/generate-image)
   - [Generate speech](https://modelfusion.dev/guide/function/generate-speech)
   - [Generate transcription](https://modelfusion.dev/guide/function/generation-transcription)
-  - [Generate structure](https://modelfusion.dev/guide/function/generate-structure)
-  - [Generate structure or text](https://modelfusion.dev/guide/function/generate-structure-or-text)
   - [Tokenize Text](https://modelfusion.dev/guide/function/tokenize-text)
   - [Embed Value](https://modelfusion.dev/guide/function/embed)
 - [Tools](https://modelfusion.dev/guide/tools)
+  - [Use Tool](https://modelfusion.dev/guide/tools/use-tool)
+  - [Use Tools](https://modelfusion.dev/guide/tools/use-tools)
+  - [Agent Loop](https://modelfusion.dev/guide/tools/agent-loop)
+  - [Available Tools](https://modelfusion.dev/guide/tools/available-tools/)
+  - [Custom Tools](https://modelfusion.dev/guide/tools/custom-tools)
+  - [Advanced](https://modelfusion.dev/guide/tools/advanced)
 - [Vector Indices](https://modelfusion.dev/guide/vector-index)
   - [Upsert](https://modelfusion.dev/guide/vector-index/upsert)
   - [Retrieve](https://modelfusion.dev/guide/vector-index/retrieve)

package/core/FunctionEvent.d.ts

@@ -1,11 +1,11 @@
-import { ExtensionFunctionStartedEvent, ExtensionFunctionFinishedEvent } from "./ExtensionFunctionEvent.js";
 import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
 import { RetrieveFinishedEvent, RetrieveStartedEvent } from "../retriever/RetrieveEvent.js";
 import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/execute-tool/ExecuteToolEvent.js";
 import { UseToolFinishedEvent, UseToolStartedEvent } from "../tool/use-tool/UseToolEvent.js";
-import { UseToolsOrGenerateTextFinishedEvent, UseToolsOrGenerateTextStartedEvent } from "../tool/use-tools-or-generate-text/UseToolsOrGenerateTextEvent.js";
+import { useToolsFinishedEvent, useToolsStartedEvent } from "../tool/use-tools/UseToolsEvent.js";
 import { UpsertIntoVectorIndexFinishedEvent, UpsertIntoVectorIndexStartedEvent } from "../vector-index/UpsertIntoVectorIndexEvent.js";
 import { ExecuteFunctionFinishedEvent, ExecuteFunctionStartedEvent } from "./ExecuteFunctionEvent.js";
+import { ExtensionFunctionFinishedEvent, ExtensionFunctionStartedEvent } from "./ExtensionFunctionEvent.js";
 export interface BaseFunctionEvent {
     /**
      * Unique identifier for the function call.
@@ -82,4 +82,4 @@ export interface BaseFunctionFinishedEvent extends BaseFunctionEvent {
      */
     result: BaseFunctionFinishedEventResult;
 }
-export type FunctionEvent = ExecuteFunctionStartedEvent | ExecuteFunctionFinishedEvent | ExecuteToolStartedEvent | ExecuteToolFinishedEvent | ExtensionFunctionStartedEvent | ExtensionFunctionFinishedEvent | ModelCallStartedEvent | ModelCallFinishedEvent | RetrieveStartedEvent | RetrieveFinishedEvent | UpsertIntoVectorIndexStartedEvent | UpsertIntoVectorIndexFinishedEvent | UseToolStartedEvent | UseToolFinishedEvent | UseToolsOrGenerateTextStartedEvent | UseToolsOrGenerateTextFinishedEvent;
+export type FunctionEvent = ExecuteFunctionStartedEvent | ExecuteFunctionFinishedEvent | ExecuteToolStartedEvent | ExecuteToolFinishedEvent | ExtensionFunctionStartedEvent | ExtensionFunctionFinishedEvent | ModelCallStartedEvent | ModelCallFinishedEvent | RetrieveStartedEvent | RetrieveFinishedEvent | UpsertIntoVectorIndexStartedEvent | UpsertIntoVectorIndexFinishedEvent | UseToolStartedEvent | UseToolFinishedEvent | useToolsStartedEvent | useToolsFinishedEvent;

package/model-function/ModelCallEvent.d.ts

@@ -1,6 +1,6 @@
 import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
 import { ToolCallGenerationFinishedEvent, ToolCallGenerationStartedEvent } from "../tool/generate-tool-call/ToolCallGenerationEvent.js";
-import { ToolCallsOrTextGenerationFinishedEvent, ToolCallsOrTextGenerationStartedEvent } from "../tool/generate-tool-calls-or-text/ToolCallsOrTextGenerationEvent.js";
+import { ToolCallsGenerationFinishedEvent, ToolCallsGenerationStartedEvent } from "../tool/generate-tool-calls/ToolCallsGenerationEvent.js";
 import { ModelInformation } from "./ModelInformation.js";
 import { EmbeddingFinishedEvent, EmbeddingStartedEvent } from "./embed/EmbeddingEvent.js";
 import { ImageGenerationFinishedEvent, ImageGenerationStartedEvent } from "./generate-image/ImageGenerationEvent.js";
@@ -49,5 +49,5 @@ export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
      */
     result: BaseModelCallFinishedEventResult;
 }
-export type ModelCallStartedEvent = EmbeddingStartedEvent | ImageGenerationStartedEvent | SpeechGenerationStartedEvent | SpeechStreamingStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | ToolCallGenerationStartedEvent | ToolCallsOrTextGenerationStartedEvent | TranscriptionStartedEvent;
-export type ModelCallFinishedEvent = EmbeddingFinishedEvent | ImageGenerationFinishedEvent | SpeechGenerationFinishedEvent | SpeechStreamingFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | ToolCallGenerationFinishedEvent | ToolCallsOrTextGenerationFinishedEvent | TranscriptionFinishedEvent;
+export type ModelCallStartedEvent = EmbeddingStartedEvent | ImageGenerationStartedEvent | SpeechGenerationStartedEvent | SpeechStreamingStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | ToolCallGenerationStartedEvent | ToolCallsGenerationStartedEvent | TranscriptionStartedEvent;
+export type ModelCallFinishedEvent = EmbeddingFinishedEvent | ImageGenerationFinishedEvent | SpeechGenerationFinishedEvent | SpeechStreamingFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | ToolCallGenerationFinishedEvent | ToolCallsGenerationFinishedEvent | TranscriptionFinishedEvent;

package/model-function/generate-structure/StructureFromTextPromptTemplate.d.ts

@@ -1,6 +1,19 @@
 import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
 import { Schema } from "../../core/schema/Schema.js";
+import { TextStreamingModel } from "../generate-text/TextGenerationModel.js";
+import { ChatPrompt } from "../generate-text/prompt-template/ChatPrompt.js";
+import { InstructionPrompt } from "../generate-text/prompt-template/InstructionPrompt.js";
 export type StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> = {
     createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => TARGET_PROMPT;
     extractStructure: (response: string) => unknown;
 };
+export type FlexibleStructureFromTextPromptTemplate<SOURCE_PROMPT, INTERMEDIATE_PROMPT> = {
+    createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => INTERMEDIATE_PROMPT;
+    extractStructure: (response: string) => unknown;
+    adaptModel: (model: TextStreamingModel<never> & {
+        withTextPrompt(): TextStreamingModel<string>;
+        withInstructionPrompt(): TextStreamingModel<InstructionPrompt>;
+        withChatPrompt(): TextStreamingModel<ChatPrompt>;
+        withJsonOutput?: () => typeof model;
+    }) => TextStreamingModel<INTERMEDIATE_PROMPT>;
+};

package/model-function/generate-structure/jsonStructurePrompt.cjs

@@ -15,6 +15,12 @@ exports.jsonStructurePrompt = {
                 instruction: prompt,
             }),
             extractStructure,
+            adaptModel: (model) => {
+                if (model.withJsonOutput != null) {
+                    model = model.withJsonOutput();
+                }
+                return model.withInstructionPrompt();
+            },
         };
     },
     instruction({ schemaPrefix, schemaSuffix, } = {}) {
@@ -29,6 +35,12 @@ exports.jsonStructurePrompt = {
                 instruction: prompt.instruction,
             }),
             extractStructure,
+            adaptModel: (model) => {
+                if (model.withJsonOutput != null) {
+                    model = model.withJsonOutput();
+                }
+                return model.withInstructionPrompt();
+            },
         };
     },
 };

package/model-function/generate-structure/jsonStructurePrompt.d.ts

@@ -1,15 +1,15 @@
 import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
 import { Schema } from "../../core/schema/Schema.js";
 import { InstructionPrompt } from "../../model-function/generate-text/prompt-template/InstructionPrompt.js";
-import { StructureFromTextPromptTemplate } from "./StructureFromTextPromptTemplate.js";
+import { FlexibleStructureFromTextPromptTemplate, StructureFromTextPromptTemplate } from "./StructureFromTextPromptTemplate.js";
 export declare const jsonStructurePrompt: {
     custom<SOURCE_PROMPT, TARGET_PROMPT>(createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => TARGET_PROMPT): StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
     text({ schemaPrefix, schemaSuffix, }?: {
         schemaPrefix?: string | undefined;
         schemaSuffix?: string | undefined;
-    }): StructureFromTextPromptTemplate<string, InstructionPrompt>;
+    }): FlexibleStructureFromTextPromptTemplate<string, InstructionPrompt>;
     instruction({ schemaPrefix, schemaSuffix, }?: {
         schemaPrefix?: string | undefined;
         schemaSuffix?: string | undefined;
-    }): StructureFromTextPromptTemplate<InstructionPrompt, InstructionPrompt>;
+    }): FlexibleStructureFromTextPromptTemplate<InstructionPrompt, InstructionPrompt>;
 };

package/model-function/generate-structure/jsonStructurePrompt.js

@@ -12,6 +12,12 @@ export const jsonStructurePrompt = {
                 instruction: prompt,
             }),
             extractStructure,
+            adaptModel: (model) => {
+                if (model.withJsonOutput != null) {
+                    model = model.withJsonOutput();
+                }
+                return model.withInstructionPrompt();
+            },
         };
     },
     instruction({ schemaPrefix, schemaSuffix, } = {}) {
@@ -26,6 +32,12 @@ export const jsonStructurePrompt = {
                 instruction: prompt.instruction,
             }),
             extractStructure,
+            adaptModel: (model) => {
+                if (model.withJsonOutput != null) {
+                    model = model.withJsonOutput();
+                }
+                return model.withInstructionPrompt();
+            },
         };
     },
 };

package/model-function/generate-text/PromptTemplateFullTextModel.cjs

@@ -10,9 +10,9 @@ class PromptTemplateFullTextModel extends PromptTemplateTextStreamingModel_js_1.
         const mappedPrompt = this.promptTemplate.format(prompt);
         return this.model.doGenerateToolCall(tool, mappedPrompt, options);
     }
-    doGenerateToolCallsOrText(tools, prompt, options) {
+    doGenerateToolCalls(tools, prompt, options) {
         const mappedPrompt = this.promptTemplate.format(prompt);
-        return this.model.doGenerateToolCallsOrText(tools, mappedPrompt, options);
+        return this.model.doGenerateToolCalls(tools, mappedPrompt, options);
     }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateFullTextModel({

package/model-function/generate-text/PromptTemplateFullTextModel.d.ts

@@ -1,11 +1,11 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 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 { ToolCallsGenerationModel } from "../../tool/generate-tool-calls/ToolCallsGenerationModel.js";
 import { PromptTemplateTextStreamingModel } from "./PromptTemplateTextStreamingModel.js";
 import { TextGenerationModelSettings, TextStreamingModel } from "./TextGenerationModel.js";
 import { TextGenerationPromptTemplate } from "./TextGenerationPromptTemplate.js";
-export declare class PromptTemplateFullTextModel<PROMPT, MODEL_PROMPT, SETTINGS extends TextGenerationModelSettings, MODEL extends TextStreamingModel<MODEL_PROMPT, SETTINGS> & ToolCallGenerationModel<MODEL_PROMPT, SETTINGS> & ToolCallsOrTextGenerationModel<MODEL_PROMPT, SETTINGS>> extends PromptTemplateTextStreamingModel<PROMPT, MODEL_PROMPT, SETTINGS, MODEL> implements TextStreamingModel<PROMPT, SETTINGS>, ToolCallGenerationModel<PROMPT, SETTINGS>, ToolCallsOrTextGenerationModel<PROMPT, SETTINGS> {
+export declare class PromptTemplateFullTextModel<PROMPT, MODEL_PROMPT, SETTINGS extends TextGenerationModelSettings, MODEL extends TextStreamingModel<MODEL_PROMPT, SETTINGS> & ToolCallGenerationModel<MODEL_PROMPT, SETTINGS> & ToolCallsGenerationModel<MODEL_PROMPT, SETTINGS>> extends PromptTemplateTextStreamingModel<PROMPT, MODEL_PROMPT, SETTINGS, MODEL> implements TextStreamingModel<PROMPT, SETTINGS>, ToolCallGenerationModel<PROMPT, SETTINGS>, ToolCallsGenerationModel<PROMPT, SETTINGS> {
     constructor(options: {
         model: MODEL;
         promptTemplate: TextGenerationPromptTemplate<PROMPT, MODEL_PROMPT>;
@@ -22,7 +22,7 @@ export declare class PromptTemplateFullTextModel<PROMPT, MODEL_PROMPT, SETTINGS
             totalTokens: number;
         } | undefined;
     }>;
-    doGenerateToolCallsOrText(tools: ToolDefinition<string, unknown>[], prompt: PROMPT, options?: FunctionOptions | undefined): PromiseLike<{
+    doGenerateToolCalls(tools: ToolDefinition<string, unknown>[], prompt: PROMPT, options?: FunctionOptions | undefined): PromiseLike<{
         response: unknown;
         text: string | null;
         toolCalls: {

package/model-function/generate-text/PromptTemplateFullTextModel.js

@@ -7,9 +7,9 @@ export class PromptTemplateFullTextModel extends PromptTemplateTextStreamingMode
         const mappedPrompt = this.promptTemplate.format(prompt);
         return this.model.doGenerateToolCall(tool, mappedPrompt, options);
     }
-    doGenerateToolCallsOrText(tools, prompt, options) {
+    doGenerateToolCalls(tools, prompt, options) {
         const mappedPrompt = this.promptTemplate.format(prompt);
-        return this.model.doGenerateToolCallsOrText(tools, mappedPrompt, options);
+        return this.model.doGenerateToolCalls(tools, mappedPrompt, options);
     }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateFullTextModel({

package/model-function/generate-text/PromptTemplateTextGenerationModel.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptTemplateTextGenerationModel = void 0;
 const TextGenerationToolCallModel_js_1 = require("../../tool/generate-tool-call/TextGenerationToolCallModel.cjs");
-const TextGenerationToolCallsOrGenerateTextModel_js_1 = require("../../tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.cjs");
+const TextGenerationToolCallsModel_js_1 = require("../../tool/generate-tool-calls/TextGenerationToolCallsModel.cjs");
 const StructureFromTextGenerationModel_js_1 = require("../generate-structure/StructureFromTextGenerationModel.cjs");
 class PromptTemplateTextGenerationModel {
     constructor({ model, promptTemplate, }) {
@@ -54,7 +54,7 @@ class PromptTemplateTextGenerationModel {
         });
     }
     asToolCallsOrTextGenerationModel(promptTemplate) {
-        return new TextGenerationToolCallsOrGenerateTextModel_js_1.TextGenerationToolCallsOrGenerateTextModel({
+        return new TextGenerationToolCallsModel_js_1.TextGenerationToolCallsModel({
             model: this,
             template: promptTemplate,
         });

package/model-function/generate-text/PromptTemplateTextGenerationModel.d.ts

@@ -1,7 +1,7 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { TextGenerationToolCallModel, ToolCallPromptTemplate } from "../../tool/generate-tool-call/TextGenerationToolCallModel.js";
-import { TextGenerationToolCallsOrGenerateTextModel } from "../../tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.js";
-import { ToolCallsOrGenerateTextPromptTemplate } from "../../tool/generate-tool-calls-or-text/ToolCallsOrGenerateTextPromptTemplate.js";
+import { TextGenerationToolCallsModel } from "../../tool/generate-tool-calls/TextGenerationToolCallsModel.js";
+import { ToolCallsPromptTemplate } from "../../tool/generate-tool-calls/ToolCallsPromptTemplate.js";
 import { StructureFromTextGenerationModel } from "../generate-structure/StructureFromTextGenerationModel.js";
 import { StructureFromTextPromptTemplate } from "../generate-structure/StructureFromTextPromptTemplate.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
@@ -29,7 +29,7 @@ export declare class PromptTemplateTextGenerationModel<PROMPT, MODEL_PROMPT, SET
     }>;
     get settingsForEvent(): Partial<SETTINGS>;
     asToolCallGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallModel<INPUT_PROMPT, PROMPT, this>;
-    asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsOrGenerateTextPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallsOrGenerateTextModel<INPUT_PROMPT, PROMPT, this>;
+    asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallsModel<INPUT_PROMPT, PROMPT, this>;
     asStructureGenerationModel<INPUT_PROMPT>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): StructureFromTextGenerationModel<INPUT_PROMPT, PROMPT, this>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): PromptTemplateTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;

package/model-function/generate-text/PromptTemplateTextGenerationModel.js

@@ -1,5 +1,5 @@
 import { TextGenerationToolCallModel, } from "../../tool/generate-tool-call/TextGenerationToolCallModel.js";
-import { TextGenerationToolCallsOrGenerateTextModel } from "../../tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.js";
+import { TextGenerationToolCallsModel } from "../../tool/generate-tool-calls/TextGenerationToolCallsModel.js";
 import { StructureFromTextGenerationModel } from "../generate-structure/StructureFromTextGenerationModel.js";
 export class PromptTemplateTextGenerationModel {
     constructor({ model, promptTemplate, }) {
@@ -51,7 +51,7 @@ export class PromptTemplateTextGenerationModel {
         });
     }
     asToolCallsOrTextGenerationModel(promptTemplate) {
-        return new TextGenerationToolCallsOrGenerateTextModel({
+        return new TextGenerationToolCallsModel({
             model: this,
             template: promptTemplate,
         });

package/model-function/generate-text/TextGenerationModel.d.ts

@@ -72,6 +72,10 @@ export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationMode
         };
     }>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationModel<INPUT_PROMPT, SETTINGS>;
+    /**
+     * Optional. When available, forces the model to return JSON as the text output.
+     */
+    withJsonOutput?(): this;
 }
 export interface TextStreamingModel<PROMPT, SETTINGS extends TextGenerationModelSettings = TextGenerationModelSettings> extends TextGenerationModel<PROMPT, SETTINGS> {
     doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<unknown>>>;

package/model-provider/mistral/MistralChatModel.d.ts

@@ -61,12 +61,12 @@ export declare class MistralChatModel extends AbstractModel<MistralChatModelSett
     doGenerateTexts(prompt: MistralChatPrompt, options?: FunctionOptions): Promise<{
         response: {
             object: string;
+            model: string;
             usage: {
                 prompt_tokens: number;
                 completion_tokens: number;
                 total_tokens: number;
             };
-            model: string;
             id: string;
             created: number;
             choices: {
@@ -162,12 +162,12 @@ declare const mistralChatResponseSchema: z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     object: string;
+    model: string;
     usage: {
         prompt_tokens: number;
         completion_tokens: number;
         total_tokens: number;
     };
-    model: string;
     id: string;
     created: number;
     choices: {
@@ -180,12 +180,12 @@ declare const mistralChatResponseSchema: z.ZodObject<{
     }[];
 }, {
     object: string;
+    model: string;
     usage: {
         prompt_tokens: number;
         completion_tokens: number;
         total_tokens: number;
     };
-    model: string;
     id: string;
     created: number;
     choices: {
@@ -271,12 +271,12 @@ export declare const MistralChatResponseFormat: {
         stream: boolean;
         handler: ResponseHandler<{
             object: string;
+            model: string;
             usage: {
                 prompt_tokens: number;
                 completion_tokens: number;
                 total_tokens: number;
             };
-            model: string;
             id: string;
             created: number;
             choices: {