modelfusion 0.103.0 → 0.105.0

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Changelog
 
+## v0.105.0 - 2023-12-26
+
+### Added
+
+- Tool call support for chat prompts. Assistant messages can contain tool calls, and tool messages can contain tool call results. Tool calls can be used to implement e.g. agents:
+
+  ```ts
+  const chat: ChatPrompt = {
+    system: "You are ...",
+    messages: [ChatMessage.user({ text: instruction })],
+  };
+
+  while (true) {
+    const { text, toolResults } = await useToolsOrGenerateText(
+      openai
+        .ChatTextGenerator({ model: "gpt-4-1106-preview" })
+        .withChatPrompt(),
+      tools, // array of tools
+      chat
+    );
+
+    // add the assistant and tool messages to the chat:
+    chat.messages.push(
+      ChatMessage.assistant({ text, toolResults }),
+      ChatMessage.tool({ toolResults })
+    );
+
+    if (toolResults == null) {
+      return; // no more actions, break loop
+    }
+
+    // ... (handle tool results)
+  }
+  ```
+
+- `streamText` returns a `text` promise when invoked with `fullResponse: true`. After the streaming has finished, the promise resolves with the full text.
+
+  ```ts
+  const { text, textStream } = await streamText(
+    openai.ChatTextGenerator({ model: "gpt-3.5-turbo" }).withTextPrompt(),
+    "Write a short story about a robot learning to love:",
+    { fullResponse: true }
+  );
+
+  // ... (handle streaming)
+
+  console.log(await text); // full text
+  ```
+
+## v0.104.0 - 2023-12-24
+
+### Changed
+
+- **breaking change**: Unified text and multimodal prompt templates. `[Text/MultiModal]InstructionPrompt` is now `InstructionPrompt`, and `[Text/MultiModalChatPrompt]` is now `ChatPrompt`.
+- More flexible chat prompts: The chat prompt validation is now chat template specific and validated at runtime. E.g. the Llama2 prompt template only supports turns of user and assistant messages, whereas other formats are more flexible.
+
 ## v0.103.0 - 2023-12-23
 
 ### Added

package/model-function/Delta.d.ts

@@ -1,7 +1,6 @@
 export type Delta<T> = {
     type: "delta";
-    fullDelta: unknown;
-    valueDelta: T;
+    deltaValue: T;
 } | {
     type: "error";
     error: unknown;

package/model-function/executeStreamCall.cjs

@@ -11,7 +11,7 @@ const getRun_js_1 = require("../core/getRun.cjs");
 const AsyncQueue_js_1 = require("../util/AsyncQueue.cjs");
 const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
 const runSafe_js_1 = require("../util/runSafe.cjs");
-async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }) {
+async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, onDone, }) {
     const run = await (0, getRun_js_1.getRun)(options?.run);
     const settings = model.settings;
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
@@ -121,6 +121,7 @@ async function executeStreamCall({ model, options, input, functionType, startStr
                     responseQueue.error(loopResult.error);
                     return; // error is handled through queue
                 }
+                onDone?.();
                 const finishMetadata = {
                     eventType: "finished",
                     ...startMetadata,
@@ -131,7 +132,6 @@ async function executeStreamCall({ model, options, input, functionType, startStr
                     ...finishMetadata,
                     result: {
                         status: "success",
-                        ...getResult(),
                     },
                 });
             }
@@ -140,7 +140,9 @@ async function executeStreamCall({ model, options, input, functionType, startStr
                 responseQueue.close();
             }
         })();
-        return responseQueue;
+        return {
+            stream: responseQueue,
+        };
     });
     if (!result.ok) {
         const finishMetadata = {
@@ -170,7 +172,7 @@ async function executeStreamCall({ model, options, input, functionType, startStr
         throw result.error;
     }
     return {
-        value: result.value,
+        value: result.value.stream,
         metadata: startMetadata,
     };
 }

package/model-function/executeStreamCall.d.ts

@@ -3,7 +3,7 @@ import { Delta } from "./Delta.js";
 import { Model, ModelSettings } from "./Model.js";
 import { ModelCallStartedEvent } from "./ModelCallEvent.js";
 import { ModelCallMetadata } from "./ModelCallMetadata.js";
-export declare function executeStreamCall<DELTA_VALUE, VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }: {
+export declare function executeStreamCall<DELTA_VALUE, VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, startStream, processDelta, processFinished, onDone, }: {
     model: MODEL;
     options?: FunctionOptions;
     input: unknown;
@@ -13,7 +13,7 @@ export declare function executeStreamCall<DELTA_VALUE, VALUE, MODEL extends Mode
         type: "delta";
     }) => VALUE | undefined;
     processFinished?: () => VALUE | undefined;
-    getResult: () => Record<string, unknown>;
+    onDone?: () => void;
 }): Promise<{
     value: AsyncIterable<VALUE>;
     metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;

package/model-function/executeStreamCall.js

@@ -8,7 +8,7 @@ import { getRun } from "../core/getRun.js";
 import { AsyncQueue } from "../util/AsyncQueue.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { runSafe } from "../util/runSafe.js";
-export async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }) {
+export async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, onDone, }) {
     const run = await getRun(options?.run);
     const settings = model.settings;
     const eventSource = new FunctionEventSource({
@@ -118,6 +118,7 @@ export async function executeStreamCall({ model, options, input, functionType, s
                     responseQueue.error(loopResult.error);
                     return; // error is handled through queue
                 }
+                onDone?.();
                 const finishMetadata = {
                     eventType: "finished",
                     ...startMetadata,
@@ -128,7 +129,6 @@ export async function executeStreamCall({ model, options, input, functionType, s
                     ...finishMetadata,
                     result: {
                         status: "success",
-                        ...getResult(),
                     },
                 });
             }
@@ -137,7 +137,9 @@ export async function executeStreamCall({ model, options, input, functionType, s
                 responseQueue.close();
             }
         })();
-        return responseQueue;
+        return {
+            stream: responseQueue,
+        };
     });
     if (!result.ok) {
         const finishMetadata = {
@@ -167,7 +169,7 @@ export async function executeStreamCall({ model, options, input, functionType, s
         throw result.error;
     }
     return {
-        value: result.value,
+        value: result.value.stream,
         metadata: startMetadata,
     };
 }

package/model-function/generate-speech/streamSpeech.cjs

@@ -21,8 +21,7 @@ async function streamSpeech(model, text, options) {
         model,
         options,
         startStream: async (options) => model.doGenerateSpeechStreamDuplex(textStream, options),
-        processDelta: (delta) => delta.valueDelta,
-        getResult: () => ({}),
+        processDelta: (delta) => delta.deltaValue,
     });
     return options?.fullResponse
         ? {

package/model-function/generate-speech/streamSpeech.js

@@ -18,8 +18,7 @@ export async function streamSpeech(model, text, options) {
         model,
         options,
         startStream: async (options) => model.doGenerateSpeechStreamDuplex(textStream, options),
-        processDelta: (delta) => delta.valueDelta,
-        getResult: () => ({}),
+        processDelta: (delta) => delta.deltaValue,
     });
     return options?.fullResponse
         ? {

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

@@ -11,35 +11,6 @@ class StructureFromTextStreamingModel extends StructureFromTextGenerationModel_j
     constructor(options) {
         super(options);
     }
-    async doStreamStructure(schema, prompt, options) {
-        const textStream = await (0, streamText_js_1.streamText)(this.model, this.template.createPrompt(prompt, schema), options);
-        const queue = new AsyncQueue_js_1.AsyncQueue();
-        // run async on purpose:
-        (async () => {
-            try {
-                let fullText = "";
-                for await (const deltaText of textStream) {
-                    fullText += deltaText;
-                    const deltaStructure = (0, parsePartialJson_js_1.parsePartialJson)(fullText);
-                    // only publish parsable structures
-                    if (deltaStructure != null) {
-                        queue.push({
-                            type: "delta",
-                            fullDelta: fullText,
-                            valueDelta: deltaStructure,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                queue.push({ type: "error", error });
-            }
-            finally {
-                queue.close();
-            }
-        })();
-        return queue;
-    }
     async doGenerateStructure(schema, prompt, options) {
         const { response, text } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, schema), {
             ...options,
@@ -59,6 +30,31 @@ class StructureFromTextStreamingModel extends StructureFromTextGenerationModel_j
             });
         }
     }
+    async doStreamStructure(schema, prompt, options) {
+        const textStream = await (0, streamText_js_1.streamText)(this.model, this.template.createPrompt(prompt, schema), options);
+        const queue = new AsyncQueue_js_1.AsyncQueue();
+        // run async on purpose:
+        (async () => {
+            try {
+                for await (const deltaText of textStream) {
+                    queue.push({ type: "delta", deltaValue: deltaText });
+                }
+            }
+            catch (error) {
+                queue.push({ type: "error", error });
+            }
+            finally {
+                queue.close();
+            }
+        })();
+        return queue;
+    }
+    extractStructureTextDelta(delta) {
+        return delta;
+    }
+    parseAccumulatedStructureText(accumulatedText) {
+        return (0, parsePartialJson_js_1.parsePartialJson)(accumulatedText);
+    }
     withSettings(additionalSettings) {
         return new StructureFromTextStreamingModel({
             model: this.model.withSettings(additionalSettings),

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

@@ -12,11 +12,13 @@ export declare class StructureFromTextStreamingModel<SOURCE_PROMPT, TARGET_PROMP
         model: MODEL;
         template: StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
     });
-    doStreamStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<AsyncQueue<Delta<unknown>>>;
     doGenerateStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<{
         response: unknown;
         value: unknown;
         valueText: string;
     }>;
+    doStreamStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<AsyncQueue<Delta<string>>>;
+    extractStructureTextDelta(delta: unknown): string;
+    parseAccumulatedStructureText(accumulatedText: string): unknown;
     withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
 }

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

@@ -8,35 +8,6 @@ export class StructureFromTextStreamingModel extends StructureFromTextGeneration
     constructor(options) {
         super(options);
     }
-    async doStreamStructure(schema, prompt, options) {
-        const textStream = await streamText(this.model, this.template.createPrompt(prompt, schema), options);
-        const queue = new AsyncQueue();
-        // run async on purpose:
-        (async () => {
-            try {
-                let fullText = "";
-                for await (const deltaText of textStream) {
-                    fullText += deltaText;
-                    const deltaStructure = parsePartialJson(fullText);
-                    // only publish parsable structures
-                    if (deltaStructure != null) {
-                        queue.push({
-                            type: "delta",
-                            fullDelta: fullText,
-                            valueDelta: deltaStructure,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                queue.push({ type: "error", error });
-            }
-            finally {
-                queue.close();
-            }
-        })();
-        return queue;
-    }
     async doGenerateStructure(schema, prompt, options) {
         const { response, text } = await generateText(this.model, this.template.createPrompt(prompt, schema), {
             ...options,
@@ -56,6 +27,31 @@ export class StructureFromTextStreamingModel extends StructureFromTextGeneration
             });
         }
     }
+    async doStreamStructure(schema, prompt, options) {
+        const textStream = await streamText(this.model, this.template.createPrompt(prompt, schema), options);
+        const queue = new AsyncQueue();
+        // run async on purpose:
+        (async () => {
+            try {
+                for await (const deltaText of textStream) {
+                    queue.push({ type: "delta", deltaValue: deltaText });
+                }
+            }
+            catch (error) {
+                queue.push({ type: "error", error });
+            }
+            finally {
+                queue.close();
+            }
+        })();
+        return queue;
+    }
+    extractStructureTextDelta(delta) {
+        return delta;
+    }
+    parseAccumulatedStructureText(accumulatedText) {
+        return parsePartialJson(accumulatedText);
+    }
     withSettings(additionalSettings) {
         return new StructureFromTextStreamingModel({
             model: this.model.withSettings(additionalSettings),

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

@@ -19,4 +19,6 @@ export interface StructureGenerationModel<PROMPT, SETTINGS extends StructureGene
 }
 export interface StructureStreamingModel<PROMPT, SETTINGS extends StructureGenerationModelSettings = StructureGenerationModelSettings> extends StructureGenerationModel<PROMPT, SETTINGS> {
     doStreamStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<unknown>>>;
+    extractStructureTextDelta(delta: unknown): string | undefined;
+    parseAccumulatedStructureText(accumulatedText: string): unknown;
 }

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

@@ -8,8 +8,8 @@ async function streamStructure(model, schema, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(schema)
         : prompt;
+    let accumulatedText = "";
     let lastStructure;
-    let lastFullDelta;
     const fullResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
         functionType: "stream-structure",
         input: prompt,
@@ -17,11 +17,14 @@ async function streamStructure(model, schema, prompt, options) {
         options,
         startStream: async (options) => model.doStreamStructure(schema, expandedPrompt, options),
         processDelta: (delta) => {
-            const latestFullDelta = delta.fullDelta;
-            const latestStructure = delta.valueDelta;
+            const textDelta = model.extractStructureTextDelta(delta.deltaValue);
+            if (textDelta == null) {
+                return undefined;
+            }
+            accumulatedText += textDelta;
+            const latestStructure = model.parseAccumulatedStructureText(accumulatedText);
             // only send a new part into the stream when the partial structure has changed:
             if (!(0, isDeepEqualData_js_1.isDeepEqualData)(lastStructure, latestStructure)) {
-                lastFullDelta = latestFullDelta;
                 lastStructure = latestStructure;
                 return {
                     isComplete: false,
@@ -42,10 +45,6 @@ async function streamStructure(model, schema, prompt, options) {
                 value: parseResult.data,
             };
         },
-        getResult: () => ({
-            response: lastFullDelta,
-            value: lastStructure,
-        }),
     });
     return options?.fullResponse
         ? {

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

@@ -27,7 +27,7 @@ export type StructureStreamPart<STRUCTURE> = {
  * @example
  * const structureStream = await streamStructure(
  *   openai.ChatTextGenerator(...).asFunctionCallStructureGenerationModel(...),
- *   new ZodSchema(
+ *   zodSchema(
  *     z.array(
  *       z.object({
  *         name: z.string(),

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

@@ -5,8 +5,8 @@ export async function streamStructure(model, schema, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(schema)
         : prompt;
+    let accumulatedText = "";
     let lastStructure;
-    let lastFullDelta;
     const fullResponse = await executeStreamCall({
         functionType: "stream-structure",
         input: prompt,
@@ -14,11 +14,14 @@ export async function streamStructure(model, schema, prompt, options) {
         options,
         startStream: async (options) => model.doStreamStructure(schema, expandedPrompt, options),
         processDelta: (delta) => {
-            const latestFullDelta = delta.fullDelta;
-            const latestStructure = delta.valueDelta;
+            const textDelta = model.extractStructureTextDelta(delta.deltaValue);
+            if (textDelta == null) {
+                return undefined;
+            }
+            accumulatedText += textDelta;
+            const latestStructure = model.parseAccumulatedStructureText(accumulatedText);
             // only send a new part into the stream when the partial structure has changed:
             if (!isDeepEqualData(lastStructure, latestStructure)) {
-                lastFullDelta = latestFullDelta;
                 lastStructure = latestStructure;
                 return {
                     isComplete: false,
@@ -39,10 +42,6 @@ export async function streamStructure(model, schema, prompt, options) {
                 value: parseResult.data,
             };
         },
-        getResult: () => ({
-            response: lastFullDelta,
-            value: lastStructure,
-        }),
     });
     return options?.fullResponse
         ? {

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptTemplateFullTextModel = void 0;
+const PromptTemplateTextStreamingModel_js_1 = require("./PromptTemplateTextStreamingModel.cjs");
+class PromptTemplateFullTextModel extends PromptTemplateTextStreamingModel_js_1.PromptTemplateTextStreamingModel {
+    constructor(options) {
+        super(options);
+    }
+    doGenerateToolCall(tool, prompt, options) {
+        const mappedPrompt = this.promptTemplate.format(prompt);
+        return this.model.doGenerateToolCall(tool, mappedPrompt, options);
+    }
+    doGenerateToolCallsOrText(tools, prompt, options) {
+        const mappedPrompt = this.promptTemplate.format(prompt);
+        return this.model.doGenerateToolCallsOrText(tools, mappedPrompt, options);
+    }
+    withPromptTemplate(promptTemplate) {
+        return new PromptTemplateFullTextModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptTemplate.stopSequences,
+                ],
+            }),
+            promptTemplate,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new PromptTemplateFullTextModel({
+            model: this.model.withSettings(additionalSettings),
+            promptTemplate: this.promptTemplate,
+        });
+    }
+}
+exports.PromptTemplateFullTextModel = PromptTemplateFullTextModel;

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

@@ -0,0 +1,41 @@
+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 { 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> {
+    constructor(options: {
+        model: MODEL;
+        promptTemplate: TextGenerationPromptTemplate<PROMPT, MODEL_PROMPT>;
+    });
+    doGenerateToolCall(tool: ToolDefinition<string, unknown>, prompt: PROMPT, options?: FunctionOptions | undefined): PromiseLike<{
+        response: unknown;
+        toolCall: {
+            id: string;
+            args: unknown;
+        } | null;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        } | undefined;
+    }>;
+    doGenerateToolCallsOrText(tools: ToolDefinition<string, unknown>[], prompt: PROMPT, options?: FunctionOptions | undefined): PromiseLike<{
+        response: unknown;
+        text: string | null;
+        toolCalls: {
+            id: string;
+            name: string;
+            args: unknown;
+        }[] | null;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        } | undefined;
+    }>;
+    withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): PromptTemplateFullTextModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
+    withSettings(additionalSettings: Partial<SETTINGS>): this;
+}

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

@@ -0,0 +1,31 @@
+import { PromptTemplateTextStreamingModel } from "./PromptTemplateTextStreamingModel.js";
+export class PromptTemplateFullTextModel extends PromptTemplateTextStreamingModel {
+    constructor(options) {
+        super(options);
+    }
+    doGenerateToolCall(tool, prompt, options) {
+        const mappedPrompt = this.promptTemplate.format(prompt);
+        return this.model.doGenerateToolCall(tool, mappedPrompt, options);
+    }
+    doGenerateToolCallsOrText(tools, prompt, options) {
+        const mappedPrompt = this.promptTemplate.format(prompt);
+        return this.model.doGenerateToolCallsOrText(tools, mappedPrompt, options);
+    }
+    withPromptTemplate(promptTemplate) {
+        return new PromptTemplateFullTextModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptTemplate.stopSequences,
+                ],
+            }),
+            promptTemplate,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new PromptTemplateFullTextModel({
+            model: this.model.withSettings(additionalSettings),
+            promptTemplate: this.promptTemplate,
+        });
+    }
+}

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

@@ -11,6 +11,9 @@ class PromptTemplateTextStreamingModel extends PromptTemplateTextGenerationModel
         const mappedPrompt = this.promptTemplate.format(prompt);
         return this.model.doStreamText(mappedPrompt, options);
     }
+    extractTextDelta(delta) {
+        return this.model.extractTextDelta(delta);
+    }
     asStructureGenerationModel(promptTemplate) {
         return new StructureFromTextStreamingModel_js_1.StructureFromTextStreamingModel({
             model: this,

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

@@ -9,7 +9,8 @@ export declare class PromptTemplateTextStreamingModel<PROMPT, MODEL_PROMPT, SETT
         model: MODEL;
         promptTemplate: TextGenerationPromptTemplate<PROMPT, MODEL_PROMPT>;
     });
-    doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<import("../Delta.js").Delta<string>>>;
+    doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<import("../Delta.js").Delta<unknown>>>;
+    extractTextDelta(delta: unknown): string | undefined;
     asStructureGenerationModel<INPUT_PROMPT>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): StructureFromTextStreamingModel<INPUT_PROMPT, PROMPT, this>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): PromptTemplateTextStreamingModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;

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

@@ -8,6 +8,9 @@ export class PromptTemplateTextStreamingModel extends PromptTemplateTextGenerati
         const mappedPrompt = this.promptTemplate.format(prompt);
         return this.model.doStreamText(mappedPrompt, options);
     }
+    extractTextDelta(delta) {
+        return this.model.extractTextDelta(delta);
+    }
     asStructureGenerationModel(promptTemplate) {
         return new StructureFromTextStreamingModel({
             model: this,

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

@@ -74,6 +74,7 @@ export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationMode
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationModel<INPUT_PROMPT, SETTINGS>;
 }
 export interface TextStreamingModel<PROMPT, SETTINGS extends TextGenerationModelSettings = TextGenerationModelSettings> extends TextGenerationModel<PROMPT, SETTINGS> {
-    doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<string>>>;
+    doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<unknown>>>;
+    extractTextDelta(delta: unknown): string | undefined;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): TextStreamingModel<INPUT_PROMPT, SETTINGS>;
 }

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

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PromptTemplateFullTextModel.cjs"), exports);
 __exportStar(require("./PromptTemplateTextGenerationModel.cjs"), exports);
 __exportStar(require("./PromptTemplateTextStreamingModel.cjs"), exports);
 __exportStar(require("./TextGenerationEvent.cjs"), exports);

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

@@ -1,3 +1,4 @@
+export * from "./PromptTemplateFullTextModel.js";
 export * from "./PromptTemplateTextGenerationModel.js";
 export * from "./PromptTemplateTextStreamingModel.js";
 export * from "./TextGenerationEvent.js";

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

@@ -1,3 +1,4 @@
+export * from "./PromptTemplateFullTextModel.js";
 export * from "./PromptTemplateTextGenerationModel.js";
 export * from "./PromptTemplateTextStreamingModel.js";
 export * from "./TextGenerationEvent.js";

package/model-function/generate-text/prompt-template/AlpacaPromptTemplate.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.instruction = exports.text = void 0;
+const ContentPart_js_1 = require("./ContentPart.cjs");
 const DEFAULT_SYSTEM_PROMPT_INPUT = "Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.";
 const DEFAULT_SYSTEM_PROMPT_NO_INPUT = "Below is an instruction that describes a task. Write a response that appropriately completes the request.";
 /**
@@ -67,7 +68,7 @@ function instruction() {
             if (prompt.system != null) {
                 text += `${prompt.system}\n`;
             }
-            text += prompt.instruction;
+            text += (0, ContentPart_js_1.validateContentIsString)(prompt.instruction, prompt);
             if (prompt.input != null) {
                 text += `\n\n### Input:\n${prompt.input}`;
             }