modelfusion 0.9.0 → 0.11.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({
@@ -451,6 +451,12 @@ Record audio with push-to-talk and transcribe it using Whisper, implemented as a
 
 TypeScript implementation of the BabyAGI classic and BabyBeeAGI.
 
+### [Wikipedia Agent](https://github.com/lgrammel/modelfusion/tree/main/examples/wikipedia-agent)
+
+> _terminal app_, _ReAct agent_, _GPT-4_, _OpenAI functions_, _tools_
+
+Get answers to questions from Wikipedia, e.g. "Who was born first, Einstein or Picasso?"
+
 ### [Middle school math agent](https://github.com/lgrammel/modelfusion/tree/main/examples/middle-school-math-agent)
 
 > _terminal app_, _agent_, _tools_, _GPT-4_

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.9.0",
+  "version": "0.11.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -67,7 +67,7 @@
     "eslint": "^8.45.0",
     "eslint-config-prettier": "9.0.0",
     "husky": "^8.0.3",
-    "lint-staged": "13.2.3",
+    "lint-staged": "14.0.0",
     "prettier": "3.0.1",
     "rimraf": "5.0.1",
     "typescript": "5.1.6",

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,14 +1,18 @@
 "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. Should be understandable for language models and unique among the tools that they know.
+         * 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,
@@ -53,11 +57,18 @@ class Tool {
             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.

package/tool/Tool.d.ts

@@ -7,7 +7,9 @@ import { RunFunction } from "../run/RunFunction.js";
  */
 export declare class Tool<NAME extends string, INPUT, OUTPUT> {
     /**
-     * The name of the tool. Should be understandable for language models and unique among the tools that they know.
+     * 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;
     /**
@@ -27,7 +29,7 @@ export declare class Tool<NAME extends string, INPUT, 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>;

package/tool/Tool.js

@@ -1,11 +1,15 @@
+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. Should be understandable for language models and unique among the tools that they know.
+         * 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,
@@ -50,11 +54,18 @@ export class Tool {
             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.

package/tool/WebSearchTool.cjs

@@ -13,31 +13,39 @@ const OUTPUT_SCHEMA = zod_1.z.object({
         snippet: zod_1.z.string(),
     })),
 });
-/**
- * @see https://serpapi.com/search-api
- */
 class WebSearchTool extends Tool_js_1.Tool {
-    constructor(options) {
+    constructor({ name, description, queryDescription = "Search query", execute, }) {
         super({
-            name: options.name,
-            description: options.description,
-            inputSchema: INPUT_SCHEMA,
+            name,
+            description,
+            inputSchema: WebSearchTool.createInputSchema(queryDescription),
             outputSchema: OUTPUT_SCHEMA,
-            execute: options.execute,
+            execute,
         });
+        Object.defineProperty(this, "outputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.outputSchema = OUTPUT_SCHEMA;
     }
 }
 exports.WebSearchTool = WebSearchTool;
 // expose the schemas to library consumers:
-Object.defineProperty(WebSearchTool, "INPUT_SCHEMA", {
+Object.defineProperty(WebSearchTool, "createInputSchema", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: INPUT_SCHEMA
+    value: (description) => 
+    // same structure, but with description:
+    zod_1.z.object({
+        query: zod_1.z.string().describe(description),
+    })
 });
-Object.defineProperty(WebSearchTool, "OUTPUT_SCHEMA", {
+Object.defineProperty(WebSearchTool, "createOutputSchema", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: OUTPUT_SCHEMA
+    value: () => OUTPUT_SCHEMA
 });

package/tool/WebSearchTool.d.ts

@@ -34,18 +34,15 @@ declare const OUTPUT_SCHEMA: z.ZodObject<{
         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<{
+    static readonly createInputSchema: (description: string) => z.ZodObject<{
         query: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         query: string;
     }, {
         query: string;
     }>;
-    static readonly OUTPUT_SCHEMA: z.ZodObject<{
+    static readonly createOutputSchema: () => z.ZodObject<{
         results: z.ZodArray<z.ZodObject<{
             title: z.ZodString;
             link: z.ZodString;
@@ -72,9 +69,11 @@ export declare class WebSearchTool<NAME extends string> extends Tool<NAME, z.inf
             snippet: string;
         }[];
     }>;
-    constructor(options: {
+    readonly outputSchema: typeof OUTPUT_SCHEMA;
+    constructor({ name, description, queryDescription, execute, }: {
         name: NAME;
         description: string;
+        queryDescription?: string;
         execute(input: z.infer<typeof INPUT_SCHEMA>): Promise<z.infer<typeof OUTPUT_SCHEMA>>;
     });
 }

package/tool/WebSearchTool.js

@@ -10,30 +10,38 @@ const OUTPUT_SCHEMA = z.object({
         snippet: z.string(),
     })),
 });
-/**
- * @see https://serpapi.com/search-api
- */
 export class WebSearchTool extends Tool {
-    constructor(options) {
+    constructor({ name, description, queryDescription = "Search query", execute, }) {
         super({
-            name: options.name,
-            description: options.description,
-            inputSchema: INPUT_SCHEMA,
+            name,
+            description,
+            inputSchema: WebSearchTool.createInputSchema(queryDescription),
             outputSchema: OUTPUT_SCHEMA,
-            execute: options.execute,
+            execute,
         });
+        Object.defineProperty(this, "outputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.outputSchema = OUTPUT_SCHEMA;
     }
 }
 // expose the schemas to library consumers:
-Object.defineProperty(WebSearchTool, "INPUT_SCHEMA", {
+Object.defineProperty(WebSearchTool, "createInputSchema", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: INPUT_SCHEMA
+    value: (description) => 
+    // same structure, but with description:
+    z.object({
+        query: z.string().describe(description),
+    })
 });
-Object.defineProperty(WebSearchTool, "OUTPUT_SCHEMA", {
+Object.defineProperty(WebSearchTool, "createOutputSchema", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: OUTPUT_SCHEMA
+    value: () => OUTPUT_SCHEMA
 });

package/tool/index.cjs

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

package/tool/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./InvalidToolNameError.js";
 export * from "./NoSuchToolError.js";
 export * from "./Tool.js";
 export * from "./ToolExecutionError.js";

package/tool/index.js

@@ -1,3 +1,4 @@
+export * from "./InvalidToolNameError.js";
 export * from "./NoSuchToolError.js";
 export * from "./Tool.js";
 export * from "./ToolExecutionError.js";