modelfusion 0.21.0 → 0.22.0

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

@@ -1,6 +1,6 @@
 import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "../../run/FunctionEventSource.js";
-import { getGlobalFunctionObservers } from "../../run/GlobalFunctionObservers.js";
+import { FunctionEventSource } from "../../core/FunctionEventSource.js";
+import { getGlobalFunctionObservers } from "../../core/GlobalFunctionObservers.js";
 import { startDurationMeasurement } from "../../util/DurationMeasurement.js";
 import { AbortError } from "../../util/api/AbortError.js";
 import { runSafe } from "../../util/runSafe.js";
@@ -69,15 +69,15 @@ async function doStreamText(model, prompt, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
+        functionType: "text-streaming",
+        input: prompt,
+        settings,
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     };
     eventSource.notify({
         ...startMetadata,
-        functionType: "text-streaming",
         eventType: "started",
-        settings,
-        prompt,
     });
     const result = await runSafe(async () => extractTextDeltas({
         deltaIterable: await model.generateDeltaStreamResponse(prompt, {
@@ -95,12 +95,11 @@ async function doStreamText(model, prompt, options) {
             };
             eventSource.notify({
                 ...finishMetadata,
-                functionType: "text-streaming",
-                status: "success",
-                settings,
-                prompt,
-                response: lastFullDelta,
-                generatedText: fullText,
+                result: {
+                    status: "success",
+                    response: lastFullDelta,
+                    output: fullText,
+                },
             });
         },
         onError: (error) => {
@@ -113,18 +112,16 @@ async function doStreamText(model, prompt, options) {
             eventSource.notify(error instanceof AbortError
                 ? {
                     ...finishMetadata,
-                    functionType: "text-streaming",
-                    status: "abort",
-                    settings,
-                    prompt,
+                    result: {
+                        status: "abort",
+                    },
                 }
                 : {
                     ...finishMetadata,
-                    functionType: "text-streaming",
-                    status: "error",
-                    settings,
-                    prompt,
-                    error,
+                    result: {
+                        status: "error",
+                        error,
+                    },
                 });
         },
     }));
@@ -138,20 +135,18 @@ async function doStreamText(model, prompt, options) {
         if (result.isAborted) {
             eventSource.notify({
                 ...finishMetadata,
-                functionType: "text-streaming",
-                status: "abort",
-                settings,
-                prompt,
+                result: {
+                    status: "abort",
+                },
             });
             throw new AbortError();
         }
         eventSource.notify({
             ...finishMetadata,
-            functionType: "text-streaming",
-            status: "error",
-            settings,
-            prompt,
-            error: result.error,
+            result: {
+                status: "error",
+                error: result.error,
+            },
         });
         throw result.error;
     }

package/model-function/synthesize-speech/SpeechSynthesisEvent.d.ts

@@ -1,20 +1,21 @@
 /// <reference types="node" resolution-mode="require"/>
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type SpeechSynthesisStartedEvent = BaseModelCallStartedEvent & {
+export interface SpeechSynthesisStartedEvent extends BaseModelCallStartedEvent {
     functionType: "speech-synthesis";
-    settings: unknown;
     text: string;
-};
-export type SpeechSynthesisFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "speech-synthesis";
-    settings: unknown;
-    text: string;
-} & ({
+}
+export type SpeechSynthesisFinishedEventResult = {
     status: "success";
-    response: Buffer;
+    response: unknown;
+    output: Buffer;
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface SpeechSynthesisFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "speech-synthesis";
+    text: string;
+    result: SpeechSynthesisFinishedEventResult;
+}

package/model-function/synthesize-speech/synthesizeSpeech.cjs

@@ -7,38 +7,12 @@ const executeCall_js_1 = require("../executeCall.cjs");
  */
 function synthesizeSpeech(model, text, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "speech-synthesis",
+        input: text,
         model,
         options,
         generateResponse: (options) => model.generateSpeechResponse(text, options),
         extractOutputValue: (buffer) => buffer,
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "speech-synthesis",
-            settings,
-            text,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "speech-synthesis",
-            status: "abort",
-            settings,
-            text,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "speech-synthesis",
-            settings,
-            text,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "speech-synthesis",
-            settings,
-            text,
-            response,
-            speech: output,
-        }),
     });
 }
 exports.synthesizeSpeech = synthesizeSpeech;

package/model-function/synthesize-speech/synthesizeSpeech.js

@@ -4,37 +4,11 @@ import { executeCall } from "../executeCall.js";
  */
 export function synthesizeSpeech(model, text, options) {
     return executeCall({
+        functionType: "speech-synthesis",
+        input: text,
         model,
         options,
         generateResponse: (options) => model.generateSpeechResponse(text, options),
         extractOutputValue: (buffer) => buffer,
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "speech-synthesis",
-            settings,
-            text,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "speech-synthesis",
-            status: "abort",
-            settings,
-            text,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "speech-synthesis",
-            settings,
-            text,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "speech-synthesis",
-            settings,
-            text,
-            response,
-            speech: output,
-        }),
     });
 }

package/model-function/transcribe-speech/TranscriptionEvent.d.ts

@@ -1,20 +1,18 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type TranscriptionStartedEvent = BaseModelCallStartedEvent & {
+export interface TranscriptionStartedEvent extends BaseModelCallStartedEvent {
     functionType: "transcription";
-    settings: unknown;
-    data: unknown;
-};
-export type TranscriptionFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "transcription";
-    settings: unknown;
-    data: unknown;
-} & ({
+}
+export type TranscriptionFinishedEventResult = {
     status: "success";
     response: unknown;
-    transcription: string;
+    output: string;
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface TranscriptionFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "transcription";
+    result: TranscriptionFinishedEventResult;
+}

package/model-function/transcribe-speech/transcribe.cjs

@@ -18,37 +18,12 @@ const executeCall_js_1 = require("../executeCall.cjs");
  */
 function transcribe(model, data, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "transcription",
+        input: data,
         model,
         options,
         generateResponse: (options) => model.generateTranscriptionResponse(data, options),
         extractOutputValue: model.extractTranscriptionText,
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "transcription",
-            settings,
-            data,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "transcription",
-            settings,
-            data,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "transcription",
-            settings,
-            data,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "transcription",
-            settings,
-            data,
-            response,
-            transcription: output,
-        }),
     });
 }
 exports.transcribe = transcribe;

package/model-function/transcribe-speech/transcribe.js

@@ -15,36 +15,11 @@ import { executeCall } from "../executeCall.js";
  */
 export function transcribe(model, data, options) {
     return executeCall({
+        functionType: "transcription",
+        input: data,
         model,
         options,
         generateResponse: (options) => model.generateTranscriptionResponse(data, options),
         extractOutputValue: model.extractTranscriptionText,
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "transcription",
-            settings,
-            data,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "transcription",
-            settings,
-            data,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "transcription",
-            settings,
-            data,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "transcription",
-            settings,
-            data,
-            response,
-            transcription: output,
-        }),
     });
 }

package/model-provider/cohere/CohereTextEmbeddingModel.d.ts

@@ -63,13 +63,13 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
     private get apiKey();
     callAPI(texts: Array<string>, options?: ModelFunctionOptions<CohereTextEmbeddingModelSettings>): Promise<CohereTextEmbeddingResponse>;
     generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<CohereTextEmbeddingModelSettings>): Promise<{
-        texts: string[];
         id: string;
         meta: {
             api_version: {
                 version: string;
             };
         };
+        texts: string[];
         embeddings: number[][];
     }>;
     extractEmbeddings(response: CohereTextEmbeddingResponse): number[][];
@@ -97,22 +97,22 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     }>;
 }, "strip", z.ZodTypeAny, {
-    texts: string[];
     id: string;
     meta: {
         api_version: {
             version: string;
         };
     };
+    texts: string[];
     embeddings: number[][];
 }, {
-    texts: string[];
     id: string;
     meta: {
         api_version: {
             version: string;
         };
     };
+    texts: string[];
     embeddings: number[][];
 }>;
 export type CohereTextEmbeddingResponse = z.infer<typeof cohereTextEmbeddingResponseSchema>;

package/model-provider/cohere/CohereTokenizer.d.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 import { FullTokenizer } 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";
 import { CohereTextGenerationModelType } from "./CohereTextGenerationModel.js";

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/package.json

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

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

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

package/tool/ExecuteToolEvent.d.ts

@@ -1,20 +1,11 @@
-import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../run/FunctionEvent.js";
-import { Tool } from "./Tool.js";
-export type ExecuteToolStartedEvent = BaseFunctionStartedEvent & {
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+export interface ExecuteToolStartedEvent extends BaseFunctionStartedEvent {
     functionType: "execute-tool";
-    tool: Tool<string, unknown, unknown>;
+    toolName: string;
     input: unknown;
-};
-export type ExecuteToolFinishedEvent = BaseFunctionFinishedEvent & {
+}
+export interface ExecuteToolFinishedEvent extends BaseFunctionFinishedEvent {
     functionType: "execute-tool";
-    tool: Tool<string, unknown, unknown>;
+    toolName: string;
     input: unknown;
-} & ({
-    status: "success";
-    output: unknown;
-} | {
-    status: "error";
-    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 { FunctionOptions } from "../run/FunctionOptions.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.

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,5 +1,33 @@
-import { FunctionOptions } from "../run/FunctionOptions.js";
+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;
 };
@@ -10,7 +38,33 @@ 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;
@@ -18,3 +72,4 @@ export declare class WebSearchTool<NAME extends string> extends Tool<NAME, WebSe
         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,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeTool = exports.ExecuteToolPromise = void 0;
 const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../run/FunctionEventSource.cjs");
-const GlobalFunctionObservers_js_1 = require("../run/GlobalFunctionObservers.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");
@@ -69,7 +69,7 @@ async function doExecuteTool(tool, input, options) {
         sessionId: run?.sessionId,
         userId: run?.userId,
         functionId: options?.functionId,
-        tool: tool,
+        toolName: tool.name,
         input,
     };
     eventSource.notify({
@@ -91,14 +91,18 @@ async function doExecuteTool(tool, input, options) {
         if (result.isAborted) {
             eventSource.notify({
                 ...finishMetadata,
-                status: "abort",
+                result: {
+                    status: "abort",
+                },
             });
             throw new AbortError_js_1.AbortError();
         }
         eventSource.notify({
             ...finishMetadata,
-            status: "error",
-            error: result.error,
+            result: {
+                status: "error",
+                error: result.error,
+            },
         });
         throw new ToolExecutionError_js_1.ToolExecutionError({
             toolName: tool.name,
@@ -111,8 +115,10 @@ async function doExecuteTool(tool, input, options) {
     const output = result.output;
     eventSource.notify({
         ...finishMetadata,
-        status: "success",
-        output,
+        result: {
+            status: "success",
+            output,
+        },
     });
     return {
         output,

package/tool/executeTool.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { FunctionOptions } from "../run/FunctionOptions.js";
+import { FunctionOptions } from "../core/FunctionOptions.js";
 import { Tool } from "./Tool.js";
 export type ExecuteToolMetadata = {
     callId: string;