modelfusion 0.21.0 → 0.23.0

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

@@ -57,6 +57,8 @@ export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITransc
     callAPI<RESULT>(data: OpenAITranscriptionInput, options: {
         responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
     } & ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): Promise<RESULT>;
+    getEventSettingProperties(): (keyof OpenAITranscriptionModelSettings)[];
+    get settingsForEvent(): Partial<OpenAITranscriptionModelSettings>;
     withSettings(additionalSettings: OpenAITranscriptionModelSettings): this;
 }
 declare const openAITranscriptionJsonSchema: z.ZodObject<{

package/model-provider/openai/OpenAITranscriptionModel.js

@@ -86,6 +86,13 @@ export class OpenAITranscriptionModel extends AbstractModel {
             call: async () => callOpenAITranscriptionAPI(callSettings),
         });
     }
+    getEventSettingProperties() {
+        return ["baseUrl"];
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = ["baseUrl"];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     withSettings(additionalSettings) {
         return new OpenAITranscriptionModel(Object.assign({}, this.settings, additionalSettings));
     }

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

@@ -170,6 +170,19 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callOpenAIChatCompletionAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "stopSequences",
+            "maxCompletionTokens",
+            "baseUrl",
+            "functions",
+            "functionCall",
+            "temperature",
+            "topP",
+            "n",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateTextResponse(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
@@ -211,6 +224,13 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         const jsonText = response.choices[0].message.function_call.arguments;
         return secure_json_parse_1.default.parse(jsonText);
     }
+    extractUsage(response) {
+        return {
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            totalTokens: response.usage.total_tokens,
+        };
+    }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
             model: this.withSettings({ stopSequences: promptFormat.stopSequences }),

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

@@ -1,8 +1,8 @@
 import z from "zod";
 import { AbstractModel } from "../../../model-function/AbstractModel.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 { JsonGenerationModel } from "../../../model-function/generate-json/JsonGenerationModel.js";
+import { JsonOrTextGenerationModel } from "../../../model-function/generate-json/JsonOrTextGenerationModel.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,7 +117,7 @@ export interface OpenAIChatSettings extends TextGenerationModelSettings, OpenAIM
  *   ),
  * ]);
  */
-export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, GenerateJsonModel<OpenAIChatSingleFunctionPrompt<unknown>, OpenAIChatResponse, OpenAIChatSettings>, GenerateJsonOrTextModel<OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, OpenAIChatResponse, OpenAIChatSettings> {
+export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, JsonGenerationModel<OpenAIChatSingleFunctionPrompt<unknown>, OpenAIChatResponse, OpenAIChatSettings>, JsonOrTextGenerationModel<OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, OpenAIChatResponse, OpenAIChatSettings> {
     constructor(settings: OpenAIChatSettings);
     readonly provider: "openai";
     get modelName(): "gpt-4" | "gpt-4-0314" | "gpt-4-0613" | "gpt-4-32k" | "gpt-4-32k-0314" | "gpt-4-32k-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0301" | "gpt-3.5-turbo-0613" | "gpt-3.5-turbo-16k" | "gpt-3.5-turbo-16k-0613";
@@ -134,16 +134,17 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
     } & ModelFunctionOptions<Partial<OpenAIChatCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
+    get settingsForEvent(): Partial<OpenAIChatSettings>;
     generateTextResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<{
         object: "chat.completion";
         model: string;
-        id: string;
-        created: number;
         usage: {
             prompt_tokens: number;
             total_tokens: number;
             completion_tokens: number;
         };
+        id: string;
+        created: number;
         choices: {
             message: {
                 content: string | null;
@@ -170,6 +171,11 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
      */
     generateJsonResponse(prompt: OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
     extractJson(response: OpenAIChatResponse): unknown;
+    extractUsage(response: OpenAIChatResponse): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): PromptFormatTextGenerationModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings, this>;
     withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;
 }
@@ -251,13 +257,13 @@ declare const openAIChatResponseSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     object: "chat.completion";
     model: string;
-    id: string;
-    created: number;
     usage: {
         prompt_tokens: number;
         total_tokens: number;
         completion_tokens: number;
     };
+    id: string;
+    created: number;
     choices: {
         message: {
             content: string | null;
@@ -274,13 +280,13 @@ declare const openAIChatResponseSchema: z.ZodObject<{
 }, {
     object: "chat.completion";
     model: string;
-    id: string;
-    created: number;
     usage: {
         prompt_tokens: number;
         total_tokens: number;
         completion_tokens: number;
     };
+    id: string;
+    created: number;
     choices: {
         message: {
             content: string | null;
@@ -309,13 +315,13 @@ export declare const OpenAIChatResponseFormat: {
         handler: ResponseHandler<{
             object: "chat.completion";
             model: string;
-            id: string;
-            created: number;
             usage: {
                 prompt_tokens: number;
                 total_tokens: number;
                 completion_tokens: number;
             };
+            id: string;
+            created: number;
             choices: {
                 message: {
                     content: string | null;

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

@@ -162,6 +162,19 @@ export class OpenAIChatModel extends AbstractModel {
             call: async () => callOpenAIChatCompletionAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "stopSequences",
+            "maxCompletionTokens",
+            "baseUrl",
+            "functions",
+            "functionCall",
+            "temperature",
+            "topP",
+            "n",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateTextResponse(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
@@ -203,6 +216,13 @@ export class OpenAIChatModel extends AbstractModel {
         const jsonText = response.choices[0].message.function_call.arguments;
         return SecureJSON.parse(jsonText);
     }
+    extractUsage(response) {
+        return {
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            totalTokens: response.usage.total_tokens,
+        };
+    }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel({
             model: this.withSettings({ stopSequences: promptFormat.stopSequences }),

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

@@ -1,5 +1,5 @@
 import z from "zod";
-import { GenerateJsonOrTextPrompt } from "../../../model-function/generate-json/GenerateJsonOrTextModel.js";
+import { JsonOrTextGenerationPrompt } from "../../../model-function/generate-json/JsonOrTextGenerationModel.js";
 import { SchemaDefinition } from "../../../model-function/generate-json/SchemaDefinition.js";
 import { Tool } from "../../../tool/Tool.js";
 import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
@@ -76,7 +76,7 @@ export declare class OpenAIChatSingleFunctionPrompt<FUNCTION> {
         };
     }[];
 }
-export declare class OpenAIChatAutoFunctionPrompt<FUNCTIONS extends Array<OpenAIFunctionDescription<any>>> implements GenerateJsonOrTextPrompt<OpenAIChatResponse> {
+export declare class OpenAIChatAutoFunctionPrompt<FUNCTIONS extends Array<OpenAIFunctionDescription<any>>> implements JsonOrTextGenerationPrompt<OpenAIChatResponse> {
     readonly messages: OpenAIChatMessage[];
     readonly fns: FUNCTIONS;
     constructor({ messages, fns, }: {

package/model-provider/stability/StabilityImageGenerationModel.cjs

@@ -64,6 +64,21 @@ class StabilityImageGenerationModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callStabilityImageGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "baseUrl",
+            "height",
+            "width",
+            "cfgScale",
+            "clipGuidancePreset",
+            "sampler",
+            "samples",
+            "seed",
+            "steps",
+            "stylePreset",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateImageResponse(prompt, options) {
         return this.callAPI(prompt, options);
     }

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

@@ -32,6 +32,7 @@ export declare class StabilityImageGenerationModel extends AbstractModel<Stabili
     get modelName(): string;
     private get apiKey();
     callAPI(input: StabilityImageGenerationPrompt, options?: ModelFunctionOptions<StabilityImageGenerationModelSettings>): Promise<StabilityImageGenerationResponse>;
+    get settingsForEvent(): Partial<StabilityImageGenerationModelSettings>;
     generateImageResponse(prompt: StabilityImageGenerationPrompt, options?: ModelFunctionOptions<StabilityImageGenerationModelSettings>): Promise<{
         artifacts: {
             seed: number;

package/model-provider/stability/StabilityImageGenerationModel.js

@@ -61,6 +61,21 @@ export class StabilityImageGenerationModel extends AbstractModel {
             call: async () => callStabilityImageGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "baseUrl",
+            "height",
+            "width",
+            "cfgScale",
+            "clipGuidancePreset",
+            "sampler",
+            "samples",
+            "seed",
+            "steps",
+            "stylePreset",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateImageResponse(prompt, options) {
         return this.callAPI(prompt, options);
     }

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.23.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/prompt/PromptFormatTextGenerationModel.cjs

@@ -65,6 +65,9 @@ class PromptFormatTextGenerationModel {
             promptFormat,
         });
     }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
     withSettings(additionalSettings) {
         return new PromptFormatTextGenerationModel({
             model: this.model.withSettings(additionalSettings),

package/prompt/PromptFormatTextGenerationModel.d.ts

@@ -19,5 +19,6 @@ export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, RESPO
     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>;
+    get settingsForEvent(): Partial<SETTINGS>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/prompt/PromptFormatTextGenerationModel.js

@@ -62,6 +62,9 @@ export class PromptFormatTextGenerationModel {
             promptFormat,
         });
     }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
     withSettings(additionalSettings) {
         return new PromptFormatTextGenerationModel({
             model: this.model.withSettings(additionalSettings),

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,10 @@
 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 GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
+const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
+const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.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");
@@ -55,6 +57,7 @@ async function doExecuteTool(tool, input, options) {
     const run = options?.run;
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
         observers: [
+            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
             ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
             ...(run?.observers ?? []),
             ...(options?.observers ?? []),
@@ -69,7 +72,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 +94,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 +118,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;

package/tool/executeTool.js

@@ -1,6 +1,8 @@
 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 { getGlobalFunctionLogging } from "../core/GlobalFunctionLogging.js";
+import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
+import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { AbortError } from "../util/api/AbortError.js";
 import { runSafe } from "../util/runSafe.js";
@@ -50,6 +52,7 @@ async function doExecuteTool(tool, input, options) {
     const run = options?.run;
     const eventSource = new FunctionEventSource({
         observers: [
+            ...getFunctionCallLogger(options?.logging ?? getGlobalFunctionLogging()),
             ...getGlobalFunctionObservers(),
             ...(run?.observers ?? []),
             ...(options?.observers ?? []),
@@ -64,7 +67,7 @@ async function doExecuteTool(tool, input, options) {
         sessionId: run?.sessionId,
         userId: run?.userId,
         functionId: options?.functionId,
-        tool: tool,
+        toolName: tool.name,
         input,
     };
     eventSource.notify({
@@ -86,14 +89,18 @@ async function doExecuteTool(tool, input, options) {
         if (result.isAborted) {
             eventSource.notify({
                 ...finishMetadata,
-                status: "abort",
+                result: {
+                    status: "abort",
+                },
             });
             throw new AbortError();
         }
         eventSource.notify({
             ...finishMetadata,
-            status: "error",
-            error: result.error,
+            result: {
+                status: "error",
+                error: result.error,
+            },
         });
         throw new ToolExecutionError({
             toolName: tool.name,
@@ -106,8 +113,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/useTool.d.ts

@@ -1,5 +1,5 @@
 import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
-import { GenerateJsonModel, GenerateJsonModelSettings } from "../model-function/generate-json/GenerateJsonModel.js";
+import { JsonGenerationModel, JsonGenerationModelSettings } from "../model-function/generate-json/JsonGenerationModel.js";
 import { Tool } from "./Tool.js";
 /**
  * `useTool` uses `generateJson` to generate parameters for a tool and then executes the tool with the parameters.
@@ -8,7 +8,7 @@ import { Tool } from "./Tool.js";
  * the parameters (`parameters` property, typed),
  * and the result of the tool execution (`result` property, typed).
  */
-export declare function useTool<PROMPT, RESPONSE, SETTINGS extends GenerateJsonModelSettings, TOOL extends Tool<any, any, any>>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, tool: TOOL, prompt: (tool: TOOL) => PROMPT, options?: ModelFunctionOptions<SETTINGS>): Promise<{
+export declare function useTool<PROMPT, RESPONSE, SETTINGS extends JsonGenerationModelSettings, TOOL extends Tool<any, any, any>>(model: JsonGenerationModel<PROMPT, RESPONSE, SETTINGS>, tool: TOOL, prompt: (tool: TOOL) => PROMPT, options?: ModelFunctionOptions<SETTINGS>): Promise<{
     tool: TOOL["name"];
     parameters: TOOL["inputSchema"];
     result: Awaited<ReturnType<TOOL["execute"]>>;

package/tool/useToolOrGenerateText.d.ts

@@ -1,5 +1,5 @@
 import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
-import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "../model-function/generate-json/GenerateJsonOrTextModel.js";
+import { JsonOrTextGenerationModel, JsonOrTextGenerationModelSettings, JsonOrTextGenerationPrompt } from "../model-function/generate-json/JsonOrTextGenerationModel.js";
 import { Tool } from "./Tool.js";
 type ToolArray<T extends Tool<any, any, any>[]> = T;
 type ToToolMap<T extends ToolArray<Tool<any, any, any>[]>> = {
@@ -14,7 +14,7 @@ type ToToolUnion<T> = {
     } : never;
 }[keyof T];
 type ToOutputValue<TOOLS extends ToolArray<Tool<any, any, any>[]>> = ToToolUnion<ToToolMap<TOOLS>>;
-export declare function useToolOrGenerateText<PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings, TOOLS extends Array<Tool<any, any, any>>>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, tools: TOOLS, prompt: (tools: TOOLS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): Promise<{
+export declare function useToolOrGenerateText<PROMPT, RESPONSE, SETTINGS extends JsonOrTextGenerationModelSettings, TOOLS extends Array<Tool<any, any, any>>>(model: JsonOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS>, tools: TOOLS, prompt: (tools: TOOLS) => PROMPT & JsonOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): Promise<{
     tool: null;
     parameters: null;
     result: null;