modelfusion 0.8.0 → 0.10.0

package/README.md

@@ -199,7 +199,7 @@ A tool is a function with a name, a description, and a schema for the input para
 
 ```ts
 const calculator = new Tool({
-  name: "calculator" as const, // mark 'as const' for type inference
+  name: "calculator",
   description: "Execute a calculation",
 
   inputSchema: z.object({

package/composed-function/summarize/summarizeRecursivelyWithTextGenerationAndTokenSplitting.cjs

@@ -17,10 +17,7 @@ async function summarizeRecursivelyWithTextGenerationAndTokenSplitting({ text, m
             tokenizer: model.tokenizer,
             maxTokensPerChunk: tokenLimit - emptyPromptTokens,
         }),
-        summarize: async (input) => {
-            const text = await (0, generateText_js_1.generateText)(model, await prompt(input), options);
-            return text;
-        },
+        summarize: async (input) => (0, generateText_js_1.generateText)(model, await prompt(input), options),
         join,
         text,
     }, options);

package/composed-function/summarize/summarizeRecursivelyWithTextGenerationAndTokenSplitting.js

@@ -14,10 +14,7 @@ export async function summarizeRecursivelyWithTextGenerationAndTokenSplitting({
             tokenizer: model.tokenizer,
             maxTokensPerChunk: tokenLimit - emptyPromptTokens,
         }),
-        summarize: async (input) => {
-            const text = await generateText(model, await prompt(input), options);
-            return text;
-        },
+        summarize: async (input) => generateText(model, await prompt(input), options),
         join,
         text,
     }, options);

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

@@ -21,4 +21,27 @@ exports.OpenAIChatMessage = {
     functionResult(name, content) {
         return { role: "function", name, content };
     },
+    /**
+     * Creates a function call chat message for tool calls.
+     */
+    toolCall({ text, tool, parameters, }) {
+        return {
+            role: "assistant",
+            content: text,
+            function_call: {
+                name: tool,
+                arguments: JSON.stringify(parameters),
+            },
+        };
+    },
+    /**
+     * Creates a function result chat message for tool call results.
+     */
+    toolResult({ tool, result }) {
+        return {
+            role: "function",
+            name: tool,
+            content: JSON.stringify(result),
+        };
+    },
 };

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

@@ -23,4 +23,30 @@ export declare const OpenAIChatMessage: {
         arguments: string;
     }): OpenAIChatMessage;
     functionResult(name: string, content: string): OpenAIChatMessage;
+    /**
+     * Creates a function call chat message for tool calls.
+     */
+    toolCall({ text, tool, parameters, }: {
+        text: string | null;
+        tool: string;
+        parameters: unknown;
+    }): {
+        role: "assistant";
+        content: string | null;
+        function_call: {
+            name: string;
+            arguments: string;
+        };
+    };
+    /**
+     * Creates a function result chat message for tool call results.
+     */
+    toolResult({ tool, result }: {
+        tool: string;
+        result: unknown;
+    }): {
+        role: "function";
+        name: string;
+        content: string;
+    };
 };

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

@@ -18,4 +18,27 @@ export const OpenAIChatMessage = {
     functionResult(name, content) {
         return { role: "function", name, content };
     },
+    /**
+     * Creates a function call chat message for tool calls.
+     */
+    toolCall({ text, tool, parameters, }) {
+        return {
+            role: "assistant",
+            content: text,
+            function_call: {
+                name: tool,
+                arguments: JSON.stringify(parameters),
+            },
+        };
+    },
+    /**
+     * Creates a function result chat message for tool call results.
+     */
+    toolResult({ tool, result }) {
+        return {
+            role: "function",
+            name: tool,
+            content: JSON.stringify(result),
+        };
+    },
 };

package/package.json

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

package/tool/InvalidToolNameError.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidToolNameError = void 0;
+class InvalidToolNameError extends Error {
+    constructor({ toolName, namePattern, }) {
+        super(`Invalid tool name '${toolName}'. The tool name must match the regular expression pattern ${namePattern}.`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "InvalidToolNameError";
+        this.toolName = toolName;
+    }
+}
+exports.InvalidToolNameError = InvalidToolNameError;

package/tool/InvalidToolNameError.d.ts

@@ -0,0 +1,7 @@
+export declare class InvalidToolNameError extends Error {
+    readonly toolName: string;
+    constructor({ toolName, namePattern, }: {
+        toolName: string;
+        namePattern: RegExp;
+    });
+}

package/tool/InvalidToolNameError.js

@@ -0,0 +1,13 @@
+export class InvalidToolNameError extends Error {
+    constructor({ toolName, namePattern, }) {
+        super(`Invalid tool name '${toolName}'. The tool name must match the regular expression pattern ${namePattern}.`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "InvalidToolNameError";
+        this.toolName = toolName;
+    }
+}

package/tool/Tool.cjs

@@ -1,44 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tool = void 0;
+const InvalidToolNameError_js_1 = require("./InvalidToolNameError.cjs");
+const namePattern = /^[a-zA-Z0-9_-]{1,64}$/;
+/**
+ * A tool is a function with a name, description and defined inputs that can be used
+ * by agents and chatbots.
+ */
 class Tool {
-    constructor(options) {
+    constructor({ name, description, inputSchema, outputSchema, execute, }) {
+        /**
+         * The name of the tool.
+         * It has to be a function name that matches the regular expression pattern '^[a-zA-Z0-9_-]{1,64}$'.
+         * Should be understandable for language models and unique among the tools that they know.
+         */
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * A description of what the tool does. Will be used by the language model to decide whether to use the tool.
+         */
         Object.defineProperty(this, "description", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * The schema of the input that the tool expects. The language model will use this to generate the input.
+         * Use descriptions to make the input understandable for the language model.
+         */
         Object.defineProperty(this, "inputSchema", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * An optional schema of the output that the tool produces. This will be used to validate the output.
+         */
         Object.defineProperty(this, "outputSchema", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * The actual execution function of the tool.
+         */
         Object.defineProperty(this, "execute", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.name = options.name;
-        this.description = options.description;
-        this.inputSchema = options.inputSchema;
-        this.outputSchema = options.outputSchema;
-        this.execute = options.execute;
+        // check that the name is a valid function name:
+        if (!namePattern.test(name)) {
+            throw new InvalidToolNameError_js_1.InvalidToolNameError({
+                toolName: name,
+                namePattern,
+            });
+        }
+        this.name = name;
+        this.description = description;
+        this.inputSchema = inputSchema;
+        this.outputSchema = outputSchema;
+        this.execute = execute;
     }
+    /**
+     * Provdes a schema definition with the name, description and schema of the input.
+     * This is used by `useTool`.
+     */
     get inputSchemaDefinition() {
         return {
             name: this.name,

package/tool/Tool.d.ts

@@ -1,18 +1,44 @@
 import { z } from "zod";
 import { SchemaDefinition } from "../model-function/generate-json/SchemaDefinition.js";
 import { RunFunction } from "../run/RunFunction.js";
+/**
+ * A tool is a function with a name, description and defined inputs that can be used
+ * by agents and chatbots.
+ */
 export declare class Tool<NAME extends string, INPUT, OUTPUT> {
+    /**
+     * The name of the tool.
+     * It has to be a function name that matches the regular expression pattern '^[a-zA-Z0-9_-]{1,64}$'.
+     * Should be understandable for language models and unique among the tools that they know.
+     */
     readonly name: NAME;
+    /**
+     * A description of what the tool does. Will be used by the language model to decide whether to use the tool.
+     */
     readonly description: string;
+    /**
+     * The schema of the input that the tool expects. The language model will use this to generate the input.
+     * Use descriptions to make the input understandable for the language model.
+     */
     readonly inputSchema: z.ZodSchema<INPUT>;
+    /**
+     * An optional schema of the output that the tool produces. This will be used to validate the output.
+     */
     readonly outputSchema?: z.ZodSchema<OUTPUT>;
+    /**
+     * The actual execution function of the tool.
+     */
     readonly execute: RunFunction<INPUT, OUTPUT>;
-    constructor(options: {
+    constructor({ name, description, inputSchema, outputSchema, execute, }: {
         name: NAME;
         description: string;
         inputSchema: z.ZodSchema<INPUT>;
         outputSchema?: z.ZodSchema<OUTPUT>;
         execute(input: INPUT): Promise<OUTPUT>;
     });
+    /**
+     * Provdes a schema definition with the name, description and schema of the input.
+     * This is used by `useTool`.
+     */
     get inputSchemaDefinition(): SchemaDefinition<NAME, INPUT>;
 }

package/tool/Tool.js

@@ -1,41 +1,76 @@
+import { InvalidToolNameError } from "./InvalidToolNameError.js";
+const namePattern = /^[a-zA-Z0-9_-]{1,64}$/;
+/**
+ * A tool is a function with a name, description and defined inputs that can be used
+ * by agents and chatbots.
+ */
 export class Tool {
-    constructor(options) {
+    constructor({ name, description, inputSchema, outputSchema, execute, }) {
+        /**
+         * The name of the tool.
+         * It has to be a function name that matches the regular expression pattern '^[a-zA-Z0-9_-]{1,64}$'.
+         * Should be understandable for language models and unique among the tools that they know.
+         */
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * A description of what the tool does. Will be used by the language model to decide whether to use the tool.
+         */
         Object.defineProperty(this, "description", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * The schema of the input that the tool expects. The language model will use this to generate the input.
+         * Use descriptions to make the input understandable for the language model.
+         */
         Object.defineProperty(this, "inputSchema", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * An optional schema of the output that the tool produces. This will be used to validate the output.
+         */
         Object.defineProperty(this, "outputSchema", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * The actual execution function of the tool.
+         */
         Object.defineProperty(this, "execute", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.name = options.name;
-        this.description = options.description;
-        this.inputSchema = options.inputSchema;
-        this.outputSchema = options.outputSchema;
-        this.execute = options.execute;
+        // check that the name is a valid function name:
+        if (!namePattern.test(name)) {
+            throw new InvalidToolNameError({
+                toolName: name,
+                namePattern,
+            });
+        }
+        this.name = name;
+        this.description = description;
+        this.inputSchema = inputSchema;
+        this.outputSchema = outputSchema;
+        this.execute = execute;
     }
+    /**
+     * Provdes a schema definition with the name, description and schema of the input.
+     * This is used by `useTool`.
+     */
     get inputSchemaDefinition() {
         return {
             name: this.name,

package/tool/WebSearchTool.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSearchTool = void 0;
+const zod_1 = require("zod");
+const Tool_js_1 = require("./Tool.cjs");
+const INPUT_SCHEMA = zod_1.z.object({
+    query: zod_1.z.string(),
+});
+const OUTPUT_SCHEMA = zod_1.z.object({
+    results: zod_1.z.array(zod_1.z.object({
+        title: zod_1.z.string(),
+        link: zod_1.z.string().url(),
+        snippet: zod_1.z.string(),
+    })),
+});
+/**
+ * @see https://serpapi.com/search-api
+ */
+class WebSearchTool extends Tool_js_1.Tool {
+    constructor(options) {
+        super({
+            name: options.name,
+            description: options.description,
+            inputSchema: INPUT_SCHEMA,
+            outputSchema: OUTPUT_SCHEMA,
+            execute: options.execute,
+        });
+    }
+}
+exports.WebSearchTool = WebSearchTool;
+// expose the schemas to library consumers:
+Object.defineProperty(WebSearchTool, "INPUT_SCHEMA", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: INPUT_SCHEMA
+});
+Object.defineProperty(WebSearchTool, "OUTPUT_SCHEMA", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: OUTPUT_SCHEMA
+});

package/tool/WebSearchTool.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { Tool } from "./Tool.js";
+declare const INPUT_SCHEMA: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+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;
+    }[];
+}>;
+/**
+ * @see https://serpapi.com/search-api
+ */
+export declare class WebSearchTool<NAME extends string> extends Tool<NAME, z.infer<typeof INPUT_SCHEMA>, z.infer<typeof OUTPUT_SCHEMA>> {
+    static readonly INPUT_SCHEMA: z.ZodObject<{
+        query: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+    }, {
+        query: string;
+    }>;
+    static readonly 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;
+        }[];
+    }>;
+    constructor(options: {
+        name: NAME;
+        description: string;
+        execute(input: z.infer<typeof INPUT_SCHEMA>): Promise<z.infer<typeof OUTPUT_SCHEMA>>;
+    });
+}
+export {};

package/tool/WebSearchTool.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { Tool } from "./Tool.js";
+const INPUT_SCHEMA = z.object({
+    query: z.string(),
+});
+const OUTPUT_SCHEMA = z.object({
+    results: z.array(z.object({
+        title: z.string(),
+        link: z.string().url(),
+        snippet: z.string(),
+    })),
+});
+/**
+ * @see https://serpapi.com/search-api
+ */
+export class WebSearchTool extends Tool {
+    constructor(options) {
+        super({
+            name: options.name,
+            description: options.description,
+            inputSchema: INPUT_SCHEMA,
+            outputSchema: OUTPUT_SCHEMA,
+            execute: options.execute,
+        });
+    }
+}
+// expose the schemas to library consumers:
+Object.defineProperty(WebSearchTool, "INPUT_SCHEMA", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: INPUT_SCHEMA
+});
+Object.defineProperty(WebSearchTool, "OUTPUT_SCHEMA", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: OUTPUT_SCHEMA
+});

package/tool/executeTool.d.ts

@@ -9,6 +9,9 @@ export type ExecuteToolMetadata = {
     startEpochSeconds: number;
     durationInMs: number;
 };
+/**
+ * `executeTool` directly executes a tool with the given parameters.
+ */
 export declare function executeTool<INPUT, OUTPUT>(tool: Tool<string, INPUT, OUTPUT>, input: INPUT, options: FunctionOptions<undefined> & {
     fullResponse: true;
 }): Promise<{

package/tool/index.cjs

@@ -14,9 +14,11 @@ 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("./InvalidToolNameError.cjs"), exports);
 __exportStar(require("./NoSuchToolError.cjs"), exports);
 __exportStar(require("./Tool.cjs"), exports);
 __exportStar(require("./ToolExecutionError.cjs"), exports);
+__exportStar(require("./WebSearchTool.cjs"), exports);
 __exportStar(require("./executeTool.cjs"), exports);
 __exportStar(require("./useTool.cjs"), exports);
 __exportStar(require("./useToolOrGenerateText.cjs"), exports);

package/tool/index.d.ts

@@ -1,6 +1,8 @@
+export * from "./InvalidToolNameError.js";
 export * from "./NoSuchToolError.js";
 export * from "./Tool.js";
 export * from "./ToolExecutionError.js";
+export * from "./WebSearchTool.js";
 export * from "./executeTool.js";
 export * from "./useTool.js";
 export * from "./useToolOrGenerateText.js";

package/tool/index.js

@@ -1,6 +1,8 @@
+export * from "./InvalidToolNameError.js";
 export * from "./NoSuchToolError.js";
 export * from "./Tool.js";
 export * from "./ToolExecutionError.js";
+export * from "./WebSearchTool.js";
 export * from "./executeTool.js";
 export * from "./useTool.js";
 export * from "./useToolOrGenerateText.js";