modelfusion 0.29.1 → 0.30.1

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.1",
+  "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
+  "version": "0.30.1",
   "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;

package/tool/WebSearchTool.js

@@ -1,18 +1,19 @@
 import { z } from "zod";
+import { ZodSchema } from "../core/structure/ZodSchema.js";
 import { Tool } from "./Tool.js";
-const OUTPUT_SCHEMA = z.object({
+const OUTPUT_SCHEMA = new ZodSchema(z.object({
     results: z.array(z.object({
         title: z.string(),
         link: z.string().url(),
         snippet: z.string(),
     })),
-});
+}));
 // expose the schemas to library consumers:
 const createInputSchema = (description) => 
 // same structure, but with description:
-z.object({
+new ZodSchema(z.object({
     query: z.string().describe(description),
-});
+}));
 /**
  * A tool for searching the web.
  *

package/tool/executeTool.cjs

@@ -5,9 +5,9 @@ const nanoid_1 = require("nanoid");
 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 AbortError_js_1 = require("../core/api/AbortError.cjs");
 const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
 const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
-const AbortError_js_1 = require("../core/api/AbortError.cjs");
 const runSafe_js_1 = require("../util/runSafe.cjs");
 const ToolExecutionError_js_1 = require("./ToolExecutionError.cjs");
 class ExecuteToolPromise extends Promise {

package/tool/executeTool.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { FunctionOptions } from "../core/FunctionOptions.js";
 import { Tool } from "./Tool.js";
 export type ExecuteToolMetadata = {
@@ -29,4 +28,4 @@ export declare class ExecuteToolPromise<OUTPUT> extends Promise<OUTPUT> {
 /**
  * `executeTool` directly executes a tool with the given parameters.
  */
-export declare function executeTool<TOOL extends Tool<any, any, any>>(tool: TOOL, input: z.infer<TOOL["inputSchema"]>, options?: FunctionOptions): ExecuteToolPromise<ReturnType<TOOL["execute"]>>;
+export declare function executeTool<TOOL extends Tool<any, any, any>>(tool: TOOL, input: TOOL["inputSchema"]["_type"], options?: FunctionOptions): ExecuteToolPromise<ReturnType<TOOL["execute"]>>;

package/tool/executeTool.js

@@ -2,9 +2,9 @@ import { nanoid as createId } from "nanoid";
 import { FunctionEventSource } from "../core/FunctionEventSource.js";
 import { getGlobalFunctionLogging } from "../core/GlobalFunctionLogging.js";
 import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
+import { AbortError } from "../core/api/AbortError.js";
 import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
-import { AbortError } from "../core/api/AbortError.js";
 import { runSafe } from "../util/runSafe.js";
 import { ToolExecutionError } from "./ToolExecutionError.js";
 export class ExecuteToolPromise extends Promise {

package/tool/useTool.cjs

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTool = void 0;
-const generateJson_js_1 = require("../model-function/generate-json/generateJson.cjs");
+const generateStructure_js_1 = require("../model-function/generate-structure/generateStructure.cjs");
 const executeTool_js_1 = require("./executeTool.cjs");
 // In this file, using 'any' is required to allow for flexibility in the inputs. The actual types are
 // retrieved through lookups such as TOOL["name"], such that any does not affect any client.
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
- * `useTool` uses `generateJson` to generate parameters for a tool and then executes the tool with the parameters.
+ * `useTool` uses `generateStructure` to generate parameters for a tool and then executes the tool with the parameters.
  *
  * @returns The result contains the name of the tool (`tool` property),
  * the parameters (`parameters` property, typed),
  * and the result of the tool execution (`result` property, typed).
  */
 async function useTool(model, tool, prompt, options) {
-    const { output: value } = await (0, generateJson_js_1.generateJson)(model, {
+    const { output: value } = await (0, generateStructure_js_1.generateStructure)(model, {
         name: tool.name,
         description: tool.description,
         schema: tool.inputSchema,

package/tool/useTool.d.ts

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