modelfusion 0.29.0 → 0.30.0

package/model-provider/openai/OpenAITextEmbeddingModel.js

@@ -50,7 +50,7 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 1
+            value: 2048
         });
         Object.defineProperty(this, "embeddingDimensions", {
             enumerable: true,
@@ -82,7 +82,7 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
     async countTokens(input) {
         return countTokens(this.tokenizer, input);
     }
-    async callAPI(text, options) {
+    async callAPI(texts, options) {
         const run = options?.run;
         const settings = options?.settings;
         const combinedSettings = {
@@ -95,7 +95,7 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
             ...combinedSettings,
             // other settings:
             abortSignal: run?.abortSignal,
-            input: text,
+            input: texts,
         };
         return callWithRetryAndThrottle({
             retry: callSettings.api?.retry,
@@ -110,7 +110,7 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
         if (texts.length > this.maxTextsPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxTextsPerCall} texts per API call.`);
         }
-        return this.callAPI(texts[0], options);
+        return this.callAPI(texts, options);
     }
     extractEmbeddings(response) {
         return [response.data[0].embedding];
@@ -121,13 +121,11 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
 }
 const openAITextEmbeddingResponseSchema = z.object({
     object: z.literal("list"),
-    data: z
-        .array(z.object({
+    data: z.array(z.object({
         object: z.literal("embedding"),
         embedding: z.array(z.number()),
         index: z.number(),
-    }))
-        .length(1),
+    })),
     model: z.string(),
     usage: z.object({
         prompt_tokens: z.number(),

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

@@ -245,7 +245,7 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
      *
      * @see https://platform.openai.com/docs/guides/gpt/function-calling
      */
-    generateJsonResponse(prompt, options) {
+    generateStructureResponse(prompt, options) {
         const settingsWithFunctionCall = Object.assign({}, options, {
             functionCall: prompt.functionCall,
             functions: prompt.functions,
@@ -257,7 +257,7 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
             run: options?.run,
         });
     }
-    extractJson(response) {
+    extractStructure(response) {
         const jsonText = response.choices[0].message.function_call.arguments;
         return secure_json_parse_1.default.parse(jsonText);
     }

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

@@ -2,8 +2,8 @@ import z from "zod";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
 import { ModelFunctionOptions } from "../../../model-function/ModelFunctionOptions.js";
 import { ApiConfiguration } from "../../../core/api/ApiConfiguration.js";
-import { JsonGenerationModel } from "../../../model-function/generate-json/JsonGenerationModel.js";
-import { JsonOrTextGenerationModel } from "../../../model-function/generate-json/JsonOrTextGenerationModel.js";
+import { StructureGenerationModel } from "../../../model-function/generate-structure/StructureGenerationModel.js";
+import { StructureOrTextGenerationModel } from "../../../model-function/generate-structure/StructureOrTextGenerationModel.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";
@@ -132,7 +132,7 @@ export interface OpenAIChatSettings extends TextGenerationModelSettings, Omit<Op
  *   ),
  * ]);
  */
-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> {
+export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, StructureGenerationModel<OpenAIChatSingleFunctionPrompt<unknown>, OpenAIChatResponse, OpenAIChatSettings>, StructureOrTextGenerationModel<OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, OpenAIChatResponse, OpenAIChatSettings> {
     constructor(settings: OpenAIChatSettings);
     readonly provider: "openai";
     get modelName(): OpenAIChatModelType;
@@ -183,8 +183,8 @@ 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?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
-    extractJson(response: OpenAIChatResponse): unknown;
+    generateStructureResponse(prompt: OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
+    extractStructure(response: OpenAIChatResponse): unknown;
     extractUsage(response: OpenAIChatResponse): {
         promptTokens: number;
         completionTokens: number;

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

@@ -236,7 +236,7 @@ export class OpenAIChatModel extends AbstractModel {
      *
      * @see https://platform.openai.com/docs/guides/gpt/function-calling
      */
-    generateJsonResponse(prompt, options) {
+    generateStructureResponse(prompt, options) {
         const settingsWithFunctionCall = Object.assign({}, options, {
             functionCall: prompt.functionCall,
             functions: prompt.functions,
@@ -248,7 +248,7 @@ export class OpenAIChatModel extends AbstractModel {
             run: options?.run,
         });
     }
-    extractJson(response) {
+    extractStructure(response) {
         const jsonText = response.choices[0].message.function_call.arguments;
         return SecureJSON.parse(jsonText);
     }

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

@@ -5,31 +5,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIChatAutoFunctionPrompt = exports.OpenAIChatSingleFunctionPrompt = exports.OpenAIChatFunctionPrompt = void 0;
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
-const zod_to_json_schema_1 = require("zod-to-json-schema");
 exports.OpenAIChatFunctionPrompt = {
     forOpenAIFunctionDescription(options) {
         return new OpenAIChatSingleFunctionPrompt(options);
     },
-    forSchema({ messages, schemaDefinition, }) {
+    forStructure({ messages, structure, }) {
         return this.forOpenAIFunctionDescription({
             messages,
             fn: {
-                name: schemaDefinition.name,
-                description: schemaDefinition.description,
-                parameters: schemaDefinition.schema,
+                name: structure.name,
+                description: structure.description,
+                parameters: structure.schema,
             },
         });
     },
-    forSchemaCurried(messages) {
-        return (schemaDefinition) => this.forSchema({
-            messages,
-            schemaDefinition,
-        });
+    forStructureCurried(messages) {
+        return (structure) => this.forStructure({ messages, structure });
     },
     forTool({ messages, tool, }) {
-        return this.forSchema({
+        return this.forStructure({
             messages,
-            schemaDefinition: tool.inputSchemaDefinition,
+            structure: tool.inputStructureDefinition,
         });
     },
     forToolCurried(messages) {
@@ -38,23 +34,23 @@ exports.OpenAIChatFunctionPrompt = {
     forOpenAIFunctionDescriptions(options) {
         return new OpenAIChatAutoFunctionPrompt(options);
     },
-    forSchemas({ messages, schemaDefinitions, }) {
+    forStructures({ messages, structures, }) {
         return this.forOpenAIFunctionDescriptions({
             messages,
-            fns: schemaDefinitions.map((schemaDefinition) => ({
-                name: schemaDefinition.name,
-                description: schemaDefinition.description,
-                parameters: schemaDefinition.schema,
+            fns: structures.map((structure) => ({
+                name: structure.name,
+                description: structure.description,
+                parameters: structure.schema,
             })),
         });
     },
-    forSchemasCurried(messages) {
-        return (schemaDefinitions) => this.forSchemas({ messages, schemaDefinitions });
+    forStructuresCurried(messages) {
+        return (structures) => this.forStructures({ messages, structures });
     },
     forTools({ messages, tools, }) {
-        return this.forSchemas({
+        return this.forStructures({
             messages,
-            schemaDefinitions: tools.map((tool) => tool.inputSchemaDefinition),
+            structures: tools.map((tool) => tool.inputStructureDefinition),
         });
     },
     forToolsCurried(messages) {
@@ -86,7 +82,7 @@ class OpenAIChatSingleFunctionPrompt {
             {
                 name: this.fn.name,
                 description: this.fn.description,
-                parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(this.fn.parameters),
+                parameters: this.fn.parameters.getJsonSchema(),
             },
         ];
     }
@@ -109,18 +105,18 @@ class OpenAIChatAutoFunctionPrompt {
         this.messages = messages;
         this.fns = fns;
     }
-    extractJsonAndText(response) {
+    extractStructureAndText(response) {
         const message = response.choices[0].message;
         const content = message.content;
         const functionCall = message.function_call;
         return functionCall == null
             ? {
-                schema: null,
+                structure: null,
                 value: null,
                 text: content ?? "",
             }
             : {
-                schema: functionCall.name,
+                structure: functionCall.name,
                 value: secure_json_parse_1.default.parse(functionCall.arguments),
                 text: content,
             };
@@ -132,7 +128,7 @@ class OpenAIChatAutoFunctionPrompt {
         return this.fns.map((fn) => ({
             name: fn.name,
             description: fn.description,
-            parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(fn.parameters),
+            parameters: fn.parameters.getJsonSchema(),
         }));
     }
 }

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

@@ -1,24 +1,24 @@
-import z from "zod";
-import { JsonOrTextGenerationPrompt } from "../../../model-function/generate-json/JsonOrTextGenerationModel.js";
-import { SchemaDefinition } from "../../../model-function/generate-json/SchemaDefinition.js";
+import { Schema } from "../../../core/structure/Schema.js";
+import { StructureDefinition } from "../../../core/structure/StructureDefinition.js";
+import { StructureOrTextGenerationPrompt } from "../../../model-function/generate-structure/StructureOrTextGenerationModel.js";
 import { Tool } from "../../../tool/Tool.js";
 import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
 import { OpenAIChatResponse } from "./OpenAIChatModel.js";
 export type OpenAIFunctionDescription<T> = {
     name: string;
     description?: string;
-    parameters: z.Schema<T>;
+    parameters: Schema<T>;
 };
 export declare const OpenAIChatFunctionPrompt: {
     forOpenAIFunctionDescription<T>(options: {
         messages: OpenAIChatMessage[];
         fn: OpenAIFunctionDescription<T>;
     }): OpenAIChatSingleFunctionPrompt<T>;
-    forSchema<STRUCTURE>({ messages, schemaDefinition, }: {
+    forStructure<STRUCTURE>({ messages, structure, }: {
         messages: OpenAIChatMessage[];
-        schemaDefinition: SchemaDefinition<any, STRUCTURE>;
+        structure: StructureDefinition<any, STRUCTURE>;
     }): OpenAIChatSingleFunctionPrompt<STRUCTURE>;
-    forSchemaCurried<STRUCTURE_1>(messages: OpenAIChatMessage[]): (schemaDefinition: SchemaDefinition<any, STRUCTURE_1>) => OpenAIChatSingleFunctionPrompt<STRUCTURE_1>;
+    forStructureCurried<STRUCTURE_1>(messages: OpenAIChatMessage[]): (structure: StructureDefinition<any, STRUCTURE_1>) => OpenAIChatSingleFunctionPrompt<STRUCTURE_1>;
     forTool<INPUT, OUTPUT>({ messages, tool, }: {
         messages: OpenAIChatMessage[];
         tool: Tool<any, INPUT, OUTPUT>;
@@ -28,18 +28,18 @@ export declare const OpenAIChatFunctionPrompt: {
         messages: OpenAIChatMessage[];
         fns: FUNCTIONS;
     }): OpenAIChatAutoFunctionPrompt<FUNCTIONS>;
-    forSchemas<SCHEMAS extends SchemaDefinition<any, any>[]>({ messages, schemaDefinitions, }: {
+    forStructures<STRUCTURES extends StructureDefinition<any, any>[]>({ messages, structures, }: {
         messages: OpenAIChatMessage[];
-        schemaDefinitions: SCHEMAS;
+        structures: STRUCTURES;
     }): OpenAIChatAutoFunctionPrompt<{
         name: any;
         description: string | undefined;
-        parameters: z.ZodType<any, z.ZodTypeDef, any>;
+        parameters: Schema<any>;
     }[]>;
-    forSchemasCurried<SCHEMAS_1 extends SchemaDefinition<any, any>[]>(messages: OpenAIChatMessage[]): (schemaDefinitions: SCHEMAS_1) => OpenAIChatAutoFunctionPrompt<{
+    forStructuresCurried<STRUCTURE_2 extends StructureDefinition<any, any>[]>(messages: OpenAIChatMessage[]): (structures: STRUCTURE_2) => OpenAIChatAutoFunctionPrompt<{
         name: any;
         description: string | undefined;
-        parameters: z.ZodType<any, z.ZodTypeDef, any>;
+        parameters: Schema<any>;
     }[]>;
     forTools<TOOLS extends Tool<any, any, any>[]>({ messages, tools, }: {
         messages: OpenAIChatMessage[];
@@ -47,12 +47,12 @@ export declare const OpenAIChatFunctionPrompt: {
     }): OpenAIChatAutoFunctionPrompt<{
         name: any;
         description: string | undefined;
-        parameters: z.ZodType<any, z.ZodTypeDef, any>;
+        parameters: Schema<any>;
     }[]>;
     forToolsCurried<TOOLS_1 extends Tool<any, any, any>[]>(messages: OpenAIChatMessage[]): (tools: TOOLS_1) => OpenAIChatAutoFunctionPrompt<{
         name: any;
         description: string | undefined;
-        parameters: z.ZodType<any, z.ZodTypeDef, any>;
+        parameters: Schema<any>;
     }[]>;
 };
 export declare class OpenAIChatSingleFunctionPrompt<FUNCTION> {
@@ -68,27 +68,22 @@ export declare class OpenAIChatSingleFunctionPrompt<FUNCTION> {
     get functions(): {
         name: string;
         description: string | undefined;
-        parameters: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type & {
-            $schema?: string | undefined;
-            definitions?: {
-                [key: string]: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type;
-            } | undefined;
-        };
+        parameters: unknown;
     }[];
 }
-export declare class OpenAIChatAutoFunctionPrompt<FUNCTIONS extends Array<OpenAIFunctionDescription<any>>> implements JsonOrTextGenerationPrompt<OpenAIChatResponse> {
+export declare class OpenAIChatAutoFunctionPrompt<FUNCTIONS extends Array<OpenAIFunctionDescription<any>>> implements StructureOrTextGenerationPrompt<OpenAIChatResponse> {
     readonly messages: OpenAIChatMessage[];
     readonly fns: FUNCTIONS;
     constructor({ messages, fns, }: {
         messages: OpenAIChatMessage[];
         fns: FUNCTIONS;
     });
-    extractJsonAndText(response: OpenAIChatResponse): {
-        schema: null;
+    extractStructureAndText(response: OpenAIChatResponse): {
+        structure: null;
         value: null;
         text: string;
     } | {
-        schema: string;
+        structure: string;
         value: any;
         text: string | null;
     };
@@ -96,11 +91,6 @@ export declare class OpenAIChatAutoFunctionPrompt<FUNCTIONS extends Array<OpenAI
     get functions(): {
         name: string;
         description: string | undefined;
-        parameters: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type & {
-            $schema?: string | undefined;
-            definitions?: {
-                [key: string]: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type;
-            } | undefined;
-        };
+        parameters: unknown;
     }[];
 }

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

@@ -1,29 +1,25 @@
 import SecureJSON from "secure-json-parse";
-import { zodToJsonSchema } from "zod-to-json-schema";
 export const OpenAIChatFunctionPrompt = {
     forOpenAIFunctionDescription(options) {
         return new OpenAIChatSingleFunctionPrompt(options);
     },
-    forSchema({ messages, schemaDefinition, }) {
+    forStructure({ messages, structure, }) {
         return this.forOpenAIFunctionDescription({
             messages,
             fn: {
-                name: schemaDefinition.name,
-                description: schemaDefinition.description,
-                parameters: schemaDefinition.schema,
+                name: structure.name,
+                description: structure.description,
+                parameters: structure.schema,
             },
         });
     },
-    forSchemaCurried(messages) {
-        return (schemaDefinition) => this.forSchema({
-            messages,
-            schemaDefinition,
-        });
+    forStructureCurried(messages) {
+        return (structure) => this.forStructure({ messages, structure });
     },
     forTool({ messages, tool, }) {
-        return this.forSchema({
+        return this.forStructure({
             messages,
-            schemaDefinition: tool.inputSchemaDefinition,
+            structure: tool.inputStructureDefinition,
         });
     },
     forToolCurried(messages) {
@@ -32,23 +28,23 @@ export const OpenAIChatFunctionPrompt = {
     forOpenAIFunctionDescriptions(options) {
         return new OpenAIChatAutoFunctionPrompt(options);
     },
-    forSchemas({ messages, schemaDefinitions, }) {
+    forStructures({ messages, structures, }) {
         return this.forOpenAIFunctionDescriptions({
             messages,
-            fns: schemaDefinitions.map((schemaDefinition) => ({
-                name: schemaDefinition.name,
-                description: schemaDefinition.description,
-                parameters: schemaDefinition.schema,
+            fns: structures.map((structure) => ({
+                name: structure.name,
+                description: structure.description,
+                parameters: structure.schema,
             })),
         });
     },
-    forSchemasCurried(messages) {
-        return (schemaDefinitions) => this.forSchemas({ messages, schemaDefinitions });
+    forStructuresCurried(messages) {
+        return (structures) => this.forStructures({ messages, structures });
     },
     forTools({ messages, tools, }) {
-        return this.forSchemas({
+        return this.forStructures({
             messages,
-            schemaDefinitions: tools.map((tool) => tool.inputSchemaDefinition),
+            structures: tools.map((tool) => tool.inputStructureDefinition),
         });
     },
     forToolsCurried(messages) {
@@ -80,7 +76,7 @@ export class OpenAIChatSingleFunctionPrompt {
             {
                 name: this.fn.name,
                 description: this.fn.description,
-                parameters: zodToJsonSchema(this.fn.parameters),
+                parameters: this.fn.parameters.getJsonSchema(),
             },
         ];
     }
@@ -102,18 +98,18 @@ export class OpenAIChatAutoFunctionPrompt {
         this.messages = messages;
         this.fns = fns;
     }
-    extractJsonAndText(response) {
+    extractStructureAndText(response) {
         const message = response.choices[0].message;
         const content = message.content;
         const functionCall = message.function_call;
         return functionCall == null
             ? {
-                schema: null,
+                structure: null,
                 value: null,
                 text: content ?? "",
             }
             : {
-                schema: functionCall.name,
+                structure: functionCall.name,
                 value: SecureJSON.parse(functionCall.arguments),
                 text: content,
             };
@@ -125,7 +121,7 @@ export class OpenAIChatAutoFunctionPrompt {
         return this.fns.map((fn) => ({
             name: fn.name,
             description: fn.description,
-            parameters: zodToJsonSchema(fn.parameters),
+            parameters: fn.parameters.getJsonSchema(),
         }));
     }
 }

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

@@ -9,6 +9,6 @@ export * from "./OpenAITranscriptionModel.js";
 export * from "./TikTokenTokenizer.js";
 export * from "./chat/OpenAIChatMessage.js";
 export * from "./chat/OpenAIChatModel.js";
-export { OpenAIChatFunctionPrompt, OpenAIFunctionDescription, } from "./chat/OpenAIChatPrompt.js";
+export { OpenAIChatFunctionPrompt } from "./chat/OpenAIChatPrompt.js";
 export { OpenAIChatDelta } from "./chat/OpenAIChatStreamIterable.js";
 export * from "./chat/countOpenAIChatMessageTokens.js";

package/model-provider/openai/index.js

@@ -9,5 +9,5 @@ export * from "./OpenAITranscriptionModel.js";
 export * from "./TikTokenTokenizer.js";
 export * from "./chat/OpenAIChatMessage.js";
 export * from "./chat/OpenAIChatModel.js";
-export { OpenAIChatFunctionPrompt, } from "./chat/OpenAIChatPrompt.js";
+export { OpenAIChatFunctionPrompt } from "./chat/OpenAIChatPrompt.js";
 export * from "./chat/countOpenAIChatMessageTokens.js";

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "modelfusion",
-  "description": "Build AI applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.29.0",
+  "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
+  "version": "0.30.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
     "llm",
     "embedding",
     "openai",
-    "cohere",
     "huggingface",
-    "stability-ai",
     "gpt-3",
     "gpt-4",
     "whisper",
     "chatbot",
-    "ai"
+    "ai",
+    "multimodal"
   ],
   "homepage": "https://modelfusion.dev/",
   "repository": {
@@ -55,7 +54,9 @@
     "eventsource-parser": "1.0.0",
     "js-tiktoken": "1.0.7",
     "nanoid": "3.3.6",
-    "secure-json-parse": "2.7.0"
+    "secure-json-parse": "2.7.0",
+    "zod": "3.22.2",
+    "zod-to-json-schema": "3.21.4"
   },
   "devDependencies": {
     "@pinecone-database/pinecone": "^0.1.6",
@@ -70,14 +71,10 @@
     "lint-staged": "14.0.1",
     "prettier": "3.0.3",
     "rimraf": "5.0.1",
-    "typescript": "5.1.6",
-    "zod": "3.22.2",
-    "zod-to-json-schema": "3.21.4"
+    "typescript": "5.1.6"
   },
   "peerDependencies": {
-    "@pinecone-database/pinecone": "*",
-    "zod": "^3",
-    "zod-to-json-schema": "^3"
+    "@pinecone-database/pinecone": "*"
   },
   "peerDependenciesMeta": {
     "@pinecone-database/pinecone": {

package/tool/Tool.cjs

@@ -71,10 +71,10 @@ class Tool {
         this.execute = execute;
     }
     /**
-     * Provdes a schema definition with the name, description and schema of the input.
+     * Provdes a structure definition with the name, description and schema of the input.
      * This is used by `useTool`.
      */
-    get inputSchemaDefinition() {
+    get inputStructureDefinition() {
         return {
             name: this.name,
             description: this.description,

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 "../core/FunctionOptions.js";
+import { Schema } from "../core/structure/Schema.js";
+import { StructureDefinition } from "../core/structure/StructureDefinition.js";
 /**
  * A tool is a function with a name, description and defined inputs that can be used
  * by agents and chatbots.
@@ -20,11 +20,11 @@ export declare class Tool<NAME extends string, INPUT, OUTPUT> {
      * 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>;
+    readonly inputSchema: Schema<INPUT>;
     /**
      * An optional schema of the output that the tool produces. This will be used to validate the output.
      */
-    readonly outputSchema?: z.ZodSchema<OUTPUT>;
+    readonly outputSchema?: Schema<OUTPUT>;
     /**
      * The actual execution function of the tool.
      */
@@ -32,13 +32,13 @@ export declare class Tool<NAME extends string, INPUT, OUTPUT> {
     constructor({ name, description, inputSchema, outputSchema, execute, }: {
         name: NAME;
         description: string;
-        inputSchema: z.ZodSchema<INPUT>;
-        outputSchema?: z.ZodSchema<OUTPUT>;
+        inputSchema: Schema<INPUT>;
+        outputSchema?: Schema<OUTPUT>;
         execute(input: INPUT, options?: FunctionOptions): PromiseLike<OUTPUT>;
     });
     /**
-     * Provdes a schema definition with the name, description and schema of the input.
+     * Provdes a structure definition with the name, description and schema of the input.
      * This is used by `useTool`.
      */
-    get inputSchemaDefinition(): SchemaDefinition<NAME, INPUT>;
+    get inputStructureDefinition(): StructureDefinition<NAME, INPUT>;
 }

package/tool/Tool.js

@@ -68,10 +68,10 @@ export class Tool {
         this.execute = execute;
     }
     /**
-     * Provdes a schema definition with the name, description and schema of the input.
+     * Provdes a structure definition with the name, description and schema of the input.
      * This is used by `useTool`.
      */
-    get inputSchemaDefinition() {
+    get inputStructureDefinition() {
         return {
             name: this.name,
             description: this.description,

package/tool/WebSearchTool.cjs

@@ -2,20 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSearchTool = void 0;
 const zod_1 = require("zod");
+const ZodSchema_js_1 = require("../core/structure/ZodSchema.cjs");
 const Tool_js_1 = require("./Tool.cjs");
-const OUTPUT_SCHEMA = zod_1.z.object({
+const OUTPUT_SCHEMA = new ZodSchema_js_1.ZodSchema(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(),
     })),
-});
+}));
 // expose the schemas to library consumers:
 const createInputSchema = (description) => 
 // same structure, but with description:
-zod_1.z.object({
+new ZodSchema_js_1.ZodSchema(zod_1.z.object({
     query: zod_1.z.string().describe(description),
-});
+}));
 /**
  * A tool for searching the web.
  *

package/tool/WebSearchTool.d.ts

@@ -1,27 +1,7 @@
-import { z } from "zod";
 import { FunctionOptions } from "../core/FunctionOptions.js";
+import { ZodSchema } from "../core/structure/ZodSchema.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;
-    }[];
-}, {
+declare const OUTPUT_SCHEMA: ZodSchema<{
     results: {
         link: string;
         title: string;