modelfusion 0.20.1 → 0.22.0

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.d.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../../model-function/embed-text/TextEmbeddingModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -23,8 +23,8 @@ export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTe
     readonly embeddingDimensions: number | undefined;
     private readonly tokenizer;
     tokenize(text: string): Promise<number[]>;
-    callAPI(texts: Array<string>, options?: FunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<LlamaCppTextEmbeddingResponse>;
-    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<{
+    callAPI(texts: Array<string>, options?: ModelFunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<LlamaCppTextEmbeddingResponse>;
+    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<{
         embedding: number[];
     }>;
     extractEmbeddings(response: LlamaCppTextEmbeddingResponse): number[][];

package/model-provider/llamacpp/LlamaCppTextGenerationModel.d.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { DeltaEvent } from "../../model-function/generate-text/DeltaEvent.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
@@ -46,9 +46,9 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
     readonly tokenizer: LlamaCppTokenizer;
     callAPI<RESPONSE>(prompt: string, options: {
         responseFormat: LlamaCppTextGenerationResponseFormatType<RESPONSE>;
-    } & FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<RESPONSE>;
+    } & ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<RESPONSE>;
     countPromptTokens(prompt: string): Promise<number>;
-    generateTextResponse(prompt: string, options?: FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<{
+    generateTextResponse(prompt: string, options?: ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<{
         model: string;
         prompt: string;
         content: string;
@@ -98,7 +98,7 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
         truncated: boolean;
     }>;
     extractText(response: LlamaCppTextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
+    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
     extractTextDelta(fullDelta: LlamaCppTextGenerationDelta): string | undefined;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, LlamaCppTextGenerationResponse, LlamaCppTextGenerationDelta, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
     withSettings(additionalSettings: Partial<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): this;

package/model-provider/llamacpp/LlamaCppTokenizer.d.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 import { BasicTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
-import { Run } from "../../run/Run.js";
+import { Run } from "../../core/Run.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
 export interface LlamaCppTokenizerSettings {

package/model-provider/openai/OpenAIImageGenerationModel.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
 import { ResponseHandler } from "../../util/api/postToApi.js";
 import { OpenAIModelSettings } from "./OpenAIModelSettings.js";
@@ -32,10 +32,10 @@ export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImag
     private get apiKey();
     callAPI<RESULT>(prompt: string, options: {
         responseFormat: OpenAIImageGenerationResponseFormatType<RESULT>;
-    } & FunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
+    } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
-    generateImageResponse(prompt: string, options?: FunctionOptions<OpenAIImageGenerationSettings>): Promise<{
+    generateImageResponse(prompt: string, options?: ModelFunctionOptions<OpenAIImageGenerationSettings>): Promise<{
         data: {
             b64_json: string;
         }[];

package/model-provider/openai/OpenAITextEmbeddingModel.d.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../../model-function/embed-text/TextEmbeddingModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -50,8 +50,8 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     readonly contextWindowSize: number;
     private get apiKey();
     countTokens(input: string): Promise<number>;
-    callAPI(text: string, options?: FunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
-    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
+    callAPI(text: string, options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
+    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
         object: "list";
         model: string;
         data: {

package/model-provider/openai/OpenAITextGenerationModel.d.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { DeltaEvent } from "../../model-function/generate-text/DeltaEvent.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
@@ -117,10 +117,10 @@ export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextG
     countPromptTokens(input: string): Promise<number>;
     callAPI<RESULT>(prompt: string, options: {
         responseFormat: OpenAITextResponseFormatType<RESULT>;
-    } & FunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
+    } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
-    generateTextResponse(prompt: string, options?: FunctionOptions<OpenAITextGenerationModelSettings>): Promise<{
+    generateTextResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<{
         object: "text_completion";
         model: string;
         id: string;
@@ -138,7 +138,7 @@ export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextG
         }[];
     }>;
     extractText(response: OpenAITextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: FunctionOptions<OpenAITextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
+    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
     extractTextDelta(fullDelta: OpenAITextGenerationDelta): string | undefined;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, OpenAITextGenerationResponse, OpenAITextGenerationDelta, OpenAITextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<OpenAITextGenerationModelSettings>): this;

package/model-provider/openai/OpenAITranscriptionModel.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/transcribe-speech/TranscriptionModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -51,12 +51,12 @@ export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITransc
     constructor(settings: OpenAITranscriptionModelSettings);
     readonly provider: "openai";
     get modelName(): "whisper-1";
-    generateTranscriptionResponse(data: OpenAITranscriptionInput, options?: FunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): PromiseLike<OpenAITranscriptionVerboseJsonResponse>;
+    generateTranscriptionResponse(data: OpenAITranscriptionInput, options?: ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): PromiseLike<OpenAITranscriptionVerboseJsonResponse>;
     extractTranscriptionText(response: OpenAITranscriptionVerboseJsonResponse): string;
     private get apiKey();
     callAPI<RESULT>(data: OpenAITranscriptionInput, options: {
         responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
-    } & FunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): Promise<RESULT>;
+    } & ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): Promise<RESULT>;
     withSettings(additionalSettings: OpenAITranscriptionModelSettings): this;
 }
 declare const openAITranscriptionJsonSchema: z.ZodObject<{

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

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../../model-function/ModelFunctionOptions.js";
 import { GenerateJsonModel } from "../../../model-function/generate-json/GenerateJsonModel.js";
 import { GenerateJsonOrTextModel } from "../../../model-function/generate-json/GenerateJsonOrTextModel.js";
 import { DeltaEvent } from "../../../model-function/generate-text/DeltaEvent.js";
@@ -131,10 +131,10 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
     countPromptTokens(messages: OpenAIChatMessage[]): Promise<number>;
     callAPI<RESULT>(messages: Array<OpenAIChatMessage>, options: {
         responseFormat: OpenAIChatResponseFormatType<RESULT>;
-    } & FunctionOptions<Partial<OpenAIChatCallSettings & OpenAIModelSettings & {
+    } & ModelFunctionOptions<Partial<OpenAIChatCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
-    generateTextResponse(prompt: OpenAIChatMessage[], options?: FunctionOptions<OpenAIChatSettings>): Promise<{
+    generateTextResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<{
         object: "chat.completion";
         model: string;
         id: string;
@@ -159,7 +159,7 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
         }[];
     }>;
     extractText(response: OpenAIChatResponse): string;
-    generateDeltaStreamResponse(prompt: OpenAIChatMessage[], options?: FunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
+    generateDeltaStreamResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
     extractTextDelta(fullDelta: OpenAIChatDelta): string | undefined;
     /**
      * JSON generation uses the OpenAI GPT function calling API.
@@ -168,7 +168,7 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
      *
      * @see https://platform.openai.com/docs/guides/gpt/function-calling
      */
-    generateJsonResponse(prompt: OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, options?: FunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
+    generateJsonResponse(prompt: OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
     extractJson(response: OpenAIChatResponse): unknown;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): PromptFormatTextGenerationModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings, this>;
     withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;

package/model-provider/stability/StabilityImageGenerationModel.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -31,8 +31,8 @@ export declare class StabilityImageGenerationModel extends AbstractModel<Stabili
     readonly provider: "stability";
     get modelName(): string;
     private get apiKey();
-    callAPI(input: StabilityImageGenerationPrompt, options?: FunctionOptions<StabilityImageGenerationModelSettings>): Promise<StabilityImageGenerationResponse>;
-    generateImageResponse(prompt: StabilityImageGenerationPrompt, options?: FunctionOptions<StabilityImageGenerationModelSettings>): Promise<{
+    callAPI(input: StabilityImageGenerationPrompt, options?: ModelFunctionOptions<StabilityImageGenerationModelSettings>): Promise<StabilityImageGenerationResponse>;
+    generateImageResponse(prompt: StabilityImageGenerationPrompt, options?: ModelFunctionOptions<StabilityImageGenerationModelSettings>): Promise<{
         artifacts: {
             seed: number;
             base64: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build AI applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.20.1",
+  "version": "0.22.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/prompt/PromptFormatTextGenerationModel.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
 import { DeltaEvent } from "../model-function/generate-text/DeltaEvent.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "./PromptFormat.js";
@@ -14,9 +14,9 @@ export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, RESPO
     get tokenizer(): MODEL["tokenizer"];
     get contextWindowSize(): MODEL["contextWindowSize"];
     get countPromptTokens(): MODEL["countPromptTokens"] extends undefined ? undefined : (prompt: PROMPT) => PromiseLike<number>;
-    generateTextResponse(prompt: PROMPT, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    generateTextResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
     extractText(response: RESPONSE): string;
-    get generateDeltaStreamResponse(): MODEL["generateDeltaStreamResponse"] extends undefined ? undefined : (prompt: PROMPT, options: FunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
+    get generateDeltaStreamResponse(): MODEL["generateDeltaStreamResponse"] extends undefined ? undefined : (prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
     get extractTextDelta(): MODEL["extractTextDelta"];
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, RESPONSE, FULL_DELTA, SETTINGS, this>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;

package/text-chunk/SimilarTextChunksFromVectorIndexRetriever.cjs

@@ -33,6 +33,7 @@ class SimilarTextChunksFromVectorIndexRetriever {
         if (options?.settings != null) {
             return this.withSettings(options.settings).retrieveTextChunks(query, {
                 functionId: options.functionId,
+                observers: options.observers,
                 run: options.run,
             });
         }

package/text-chunk/SimilarTextChunksFromVectorIndexRetriever.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../model-function/embed-text/TextEmbeddingModel.js";
 import { TextChunk } from "./TextChunk.js";
 import { TextChunkRetriever, TextChunkRetrieverSettings } from "./retrieve-text-chunks/TextChunkRetriever.js";
@@ -15,6 +15,6 @@ export declare class SimilarTextChunksFromVectorIndexRetriever<CHUNK extends Tex
         vectorIndex: VectorIndex<CHUNK, INDEX>;
         embeddingModel: TextEmbeddingModel<unknown, SETTINGS>;
     } & SimilarTextChunksFromVectorIndexRetrieverSettings);
-    retrieveTextChunks(query: string, options?: FunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
+    retrieveTextChunks(query: string, options?: ModelFunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
     withSettings(additionalSettings: Partial<SimilarTextChunksFromVectorIndexRetrieverSettings>): this;
 }

package/text-chunk/SimilarTextChunksFromVectorIndexRetriever.js

@@ -30,6 +30,7 @@ export class SimilarTextChunksFromVectorIndexRetriever {
         if (options?.settings != null) {
             return this.withSettings(options.settings).retrieveTextChunks(query, {
                 functionId: options.functionId,
+                observers: options.observers,
                 run: options.run,
             });
         }

package/text-chunk/retrieve-text-chunks/TextChunkRetriever.d.ts

@@ -1,8 +1,8 @@
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextChunk } from "../TextChunk.js";
 export interface TextChunkRetrieverSettings {
 }
 export interface TextChunkRetriever<CHUNK extends TextChunk, QUERY, SETTINGS extends TextChunkRetrieverSettings> {
-    retrieveTextChunks(query: QUERY, options?: FunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
+    retrieveTextChunks(query: QUERY, options?: ModelFunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/text-chunk/retrieve-text-chunks/retrieveTextChunks.d.ts

@@ -1,6 +1,6 @@
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextChunk } from "../TextChunk.js";
 import { TextChunkRetriever, TextChunkRetrieverSettings } from "./TextChunkRetriever.js";
-export declare function retrieveTextChunks<CHUNK extends TextChunk, QUERY, SETTINGS extends TextChunkRetrieverSettings>(retriever: TextChunkRetriever<CHUNK, QUERY, SETTINGS>, query: QUERY, options?: FunctionOptions<SETTINGS>): Promise<{
+export declare function retrieveTextChunks<CHUNK extends TextChunk, QUERY, SETTINGS extends TextChunkRetrieverSettings>(retriever: TextChunkRetriever<CHUNK, QUERY, SETTINGS>, query: QUERY, options?: ModelFunctionOptions<SETTINGS>): Promise<{
     chunks: CHUNK[];
 }>;

package/text-chunk/split/SplitFunction.d.ts

@@ -1,4 +1,4 @@
-import { RunFunction } from "../../run/RunFunction.js";
-export type SplitFunction = RunFunction<{
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+export type SplitFunction = (input: {
     text: string;
-}, Array<string>>;
+}, options?: FunctionOptions) => PromiseLike<Array<string>>;

package/text-chunk/upsertTextChunks.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../model-function/embed-text/TextEmbeddingModel.js";
 import { TextChunk } from "./TextChunk.js";
 import { VectorIndex } from "../vector-index/VectorIndex.js";
@@ -8,4 +8,4 @@ export declare function upsertTextChunks<CHUNK extends TextChunk, SETTINGS exten
     generateId?: () => string;
     chunks: CHUNK[];
     ids?: Array<string | undefined>;
-}, options?: FunctionOptions<SETTINGS>): Promise<void>;
+}, options?: ModelFunctionOptions<SETTINGS>): Promise<void>;

package/tool/ExecuteToolEvent.d.ts

@@ -1,22 +1,11 @@
-import { RunFunctionFinishedEventMetadata, RunFunctionStartedEventMetadata } from "../run/RunFunctionEvent.js";
-import { Tool } from "./Tool.js";
-export type ExecuteToolStartedEvent = {
-    type: "execute-tool-started";
-    metadata: RunFunctionStartedEventMetadata;
-    tool: Tool<string, unknown, unknown>;
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+export interface ExecuteToolStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "execute-tool";
+    toolName: string;
     input: unknown;
-};
-export type ExecuteToolFinishedEvent = {
-    type: "execute-tool-finished";
-    metadata: RunFunctionFinishedEventMetadata;
-    tool: Tool<string, unknown, unknown>;
+}
+export interface ExecuteToolFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "execute-tool";
+    toolName: string;
     input: unknown;
-} & ({
-    status: "success";
-    output: unknown;
-} | {
-    status: "failure";
-    error: unknown;
-} | {
-    status: "abort";
-});
+}

package/tool/Tool.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { SchemaDefinition } from "../model-function/generate-json/SchemaDefinition.js";
-import { RunFunction } from "../run/RunFunction.js";
+import { FunctionOptions } from "../core/FunctionOptions.js";
 /**
  * A tool is a function with a name, description and defined inputs that can be used
  * by agents and chatbots.
@@ -28,13 +28,13 @@ export declare class Tool<NAME extends string, INPUT, OUTPUT> {
     /**
      * The actual execution function of the tool.
      */
-    readonly execute: RunFunction<INPUT, OUTPUT>;
+    readonly execute: (input: INPUT, options?: FunctionOptions) => PromiseLike<OUTPUT>;
     constructor({ name, description, inputSchema, outputSchema, execute, }: {
         name: NAME;
         description: string;
         inputSchema: z.ZodSchema<INPUT>;
         outputSchema?: z.ZodSchema<OUTPUT>;
-        execute(input: INPUT): Promise<OUTPUT>;
+        execute(input: INPUT, options?: FunctionOptions): PromiseLike<OUTPUT>;
     });
     /**
      * Provdes a schema definition with the name, description and schema of the input.

package/tool/WebSearchTool.cjs

@@ -16,6 +16,31 @@ const createInputSchema = (description) =>
 zod_1.z.object({
     query: zod_1.z.string().describe(description),
 });
+/**
+ * A tool for searching the web.
+ *
+ * The input schema takes a query string.
+ * ```ts
+ * {
+ *   query: "How many people live in Berlin?"
+ * }
+ * ```
+ *
+ * The output schema is an array of search results with title, link and snippet.
+ * ```ts
+ * {
+ *  results:
+ *   [
+ *     {
+ *       title: "Berlin - Wikipedia",
+ *       link: "https://en.wikipedia.org/wiki/Berlin",
+ *       snippet: "Berlin is the capital and largest city of Germany by...",
+ *     },
+ *     ...
+ *   ]
+ * }
+ * ```
+ */
 class WebSearchTool extends Tool_js_1.Tool {
     constructor({ name, description, queryDescription = "Search query", execute, }) {
         super({

package/tool/WebSearchTool.d.ts

@@ -1,4 +1,33 @@
+import { z } from "zod";
+import { FunctionOptions } from "../core/FunctionOptions.js";
 import { Tool } from "./Tool.js";
+declare const OUTPUT_SCHEMA: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        link: z.ZodString;
+        snippet: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        link: string;
+        title: string;
+        snippet: string;
+    }, {
+        link: string;
+        title: string;
+        snippet: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    results: {
+        link: string;
+        title: string;
+        snippet: string;
+    }[];
+}, {
+    results: {
+        link: string;
+        title: string;
+        snippet: string;
+    }[];
+}>;
 export type WebSearchToolInput = {
     query: string;
 };
@@ -9,11 +38,38 @@ export type WebSearchToolOutput = {
         snippet: string;
     }[];
 };
+/**
+ * A tool for searching the web.
+ *
+ * The input schema takes a query string.
+ * ```ts
+ * {
+ *   query: "How many people live in Berlin?"
+ * }
+ * ```
+ *
+ * The output schema is an array of search results with title, link and snippet.
+ * ```ts
+ * {
+ *  results:
+ *   [
+ *     {
+ *       title: "Berlin - Wikipedia",
+ *       link: "https://en.wikipedia.org/wiki/Berlin",
+ *       snippet: "Berlin is the capital and largest city of Germany by...",
+ *     },
+ *     ...
+ *   ]
+ * }
+ * ```
+ */
 export declare class WebSearchTool<NAME extends string> extends Tool<NAME, WebSearchToolInput, WebSearchToolOutput> {
+    readonly outputSchema: typeof OUTPUT_SCHEMA;
     constructor({ name, description, queryDescription, execute, }: {
         name: NAME;
         description: string;
         queryDescription?: string;
-        execute(input: WebSearchToolInput): Promise<WebSearchToolOutput>;
+        execute(input: WebSearchToolInput, options?: FunctionOptions): PromiseLike<WebSearchToolOutput>;
     });
 }
+export {};

package/tool/WebSearchTool.js

@@ -13,6 +13,31 @@ const createInputSchema = (description) =>
 z.object({
     query: z.string().describe(description),
 });
+/**
+ * A tool for searching the web.
+ *
+ * The input schema takes a query string.
+ * ```ts
+ * {
+ *   query: "How many people live in Berlin?"
+ * }
+ * ```
+ *
+ * The output schema is an array of search results with title, link and snippet.
+ * ```ts
+ * {
+ *  results:
+ *   [
+ *     {
+ *       title: "Berlin - Wikipedia",
+ *       link: "https://en.wikipedia.org/wiki/Berlin",
+ *       snippet: "Berlin is the capital and largest city of Germany by...",
+ *     },
+ *     ...
+ *   ]
+ * }
+ * ```
+ */
 export class WebSearchTool extends Tool {
     constructor({ name, description, queryDescription = "Search query", execute, }) {
         super({

package/tool/executeTool.cjs

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeTool = exports.ExecuteToolPromise = void 0;
 const nanoid_1 = require("nanoid");
-const RunFunctionEventSource_js_1 = require("../run/RunFunctionEventSource.cjs");
+const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
+const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
 const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
 const AbortError_js_1 = require("../util/api/AbortError.cjs");
 const runSafe_js_1 = require("../util/runSafe.cjs");
@@ -52,48 +53,56 @@ exports.executeTool = executeTool;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function doExecuteTool(tool, input, options) {
     const run = options?.run;
-    const eventSource = new RunFunctionEventSource_js_1.RunFunctionEventSource({
-        observers: run?.observers ?? [],
+    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
+        observers: [
+            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
+            ...(run?.observers ?? []),
+            ...(options?.observers ?? []),
+        ],
         errorHandler: run?.errorHandler,
     });
     const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
-    const startMetadata = {
+    const metadata = {
+        functionType: "execute-tool",
         callId: `call-${(0, nanoid_1.nanoid)()}`,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
         functionId: options?.functionId,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
-    };
-    eventSource.notifyRunFunctionStarted({
-        type: "execute-tool-started",
-        metadata: startMetadata,
-        tool: tool,
+        toolName: tool.name,
         input,
+    };
+    eventSource.notify({
+        ...metadata,
+        eventType: "started",
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     });
     const result = await (0, runSafe_js_1.runSafe)(() => tool.execute(input, options));
     const finishMetadata = {
-        ...startMetadata,
+        ...metadata,
+        eventType: "finished",
+        timestamp: new Date(),
+        startTimestamp: durationMeasurement.startDate,
+        finishTimestamp: new Date(),
         durationInMs: durationMeasurement.durationInMs,
     };
     if (!result.ok) {
         if (result.isAborted) {
-            eventSource.notifyRunFunctionFinished({
-                type: "execute-tool-finished",
-                status: "abort",
-                metadata: finishMetadata,
-                tool: tool,
-                input,
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "abort",
+                },
             });
             throw new AbortError_js_1.AbortError();
         }
-        eventSource.notifyRunFunctionFinished({
-            type: "execute-tool-finished",
-            status: "failure",
-            metadata: finishMetadata,
-            tool: tool,
-            input,
-            error: result.error,
+        eventSource.notify({
+            ...finishMetadata,
+            result: {
+                status: "error",
+                error: result.error,
+            },
         });
         throw new ToolExecutionError_js_1.ToolExecutionError({
             toolName: tool.name,
@@ -104,13 +113,12 @@ async function doExecuteTool(tool, input, options) {
         });
     }
     const output = result.output;
-    eventSource.notifyRunFunctionFinished({
-        type: "execute-tool-finished",
-        status: "success",
-        metadata: finishMetadata,
-        tool: tool,
-        input,
-        output,
+    eventSource.notify({
+        ...finishMetadata,
+        result: {
+            status: "success",
+            output,
+        },
     });
     return {
         output,