modelfusion 0.70.0 → 0.72.0

package/tool/generate-tool-calls-or-text/generateToolCallsOrText.d.ts

@@ -0,0 +1,33 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ModelCallMetadata } from "../../model-function/ModelCallMetadata.js";
+import { ToolDefinition } from "../ToolDefinition.js";
+import { ToolCallsOrTextGenerationModel, ToolCallsOrTextGenerationModelSettings } from "./ToolCallsOrTextGenerationModel.js";
+type ToolCallDefinitionArray<T extends ToolDefinition<any, any>[]> = T;
+type ToToolCallDefinitionMap<T extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = {
+    [K in T[number]["name"]]: Extract<T[number], ToolDefinition<K, any>>;
+};
+type ToToolCallUnion<T> = {
+    [KEY in keyof T]: T[KEY] extends ToolDefinition<any, infer PARAMETERS> ? {
+        id: string;
+        name: KEY;
+        args: PARAMETERS;
+    } : never;
+}[keyof T];
+type ToOutputValue<TOOL_CALLS extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = ToToolCallUnion<ToToolCallDefinitionMap<TOOL_CALLS>>;
+export declare function generateToolCallsOrText<TOOLS extends Array<ToolDefinition<any, any>>, PROMPT>(model: ToolCallsOrTextGenerationModel<PROMPT, ToolCallsOrTextGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((structureDefinitions: TOOLS) => PROMPT), options?: FunctionOptions & {
+    returnType?: "structure";
+}): Promise<{
+    text: string | null;
+    toolCalls: Array<ToOutputValue<TOOLS>> | null;
+}>;
+export declare function generateToolCallsOrText<TOOLS extends ToolDefinition<any, any>[], PROMPT>(model: ToolCallsOrTextGenerationModel<PROMPT, ToolCallsOrTextGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((structureDefinitions: TOOLS) => PROMPT), options: FunctionOptions & {
+    returnType?: "full";
+}): Promise<{
+    value: {
+        text: string | null;
+        toolCalls: Array<ToOutputValue<TOOLS>>;
+    };
+    response: unknown;
+    metadata: ModelCallMetadata;
+}>;
+export {};

package/tool/generate-tool-calls-or-text/generateToolCallsOrText.js

@@ -0,0 +1,59 @@
+import { executeStandardCall } from "../../model-function/executeStandardCall.js";
+import { NoSuchToolDefinitionError } from "../NoSuchToolDefinitionError.js";
+import { ToolCallArgumentsValidationError } from "../ToolCallArgumentsValidationError.js";
+export async function generateToolCallsOrText(model, tools, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tools)
+        : prompt;
+    const fullResponse = await executeStandardCall({
+        functionType: "generate-tool-calls-or-text",
+        input: expandedPrompt,
+        model,
+        options,
+        generateResponse: async (options) => {
+            const result = await model.doGenerateToolCallsOrText(tools, expandedPrompt, options);
+            const { text, toolCalls: rawToolCalls } = result;
+            // no tool calls:
+            if (rawToolCalls == null) {
+                return {
+                    response: result.response,
+                    extractedValue: { text, toolCalls: null },
+                    usage: result.usage,
+                };
+            }
+            // map tool calls:
+            const toolCalls = rawToolCalls.map((rawToolCall) => {
+                const tool = tools.find((tool) => tool.name === rawToolCall.name);
+                if (tool == undefined) {
+                    throw new NoSuchToolDefinitionError({
+                        toolName: rawToolCall.name,
+                        parameters: rawToolCall.args,
+                    });
+                }
+                const parseResult = tool.parameters.validate(rawToolCall.args);
+                if (!parseResult.success) {
+                    throw new ToolCallArgumentsValidationError({
+                        toolName: tool.name,
+                        args: rawToolCall.args,
+                        cause: parseResult.error,
+                    });
+                }
+                return {
+                    id: rawToolCall.id,
+                    name: tool.name,
+                    args: parseResult.data,
+                };
+            });
+            return {
+                response: result.response,
+                extractedValue: {
+                    text,
+                    toolCalls: toolCalls,
+                },
+                usage: result.usage,
+            };
+        },
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+}

package/tool/generate-tool-calls-or-text/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./ToolCallsOrTextGenerationEvent.cjs"), exports);
+__exportStar(require("./ToolCallsOrTextGenerationModel.cjs"), exports);
+__exportStar(require("./generateToolCallsOrText.cjs"), exports);

package/tool/generate-tool-calls-or-text/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ToolCallsOrTextGenerationEvent.js";
+export * from "./ToolCallsOrTextGenerationModel.js";
+export * from "./generateToolCallsOrText.js";

package/tool/generate-tool-calls-or-text/index.js

@@ -0,0 +1,3 @@
+export * from "./ToolCallsOrTextGenerationEvent.js";
+export * from "./ToolCallsOrTextGenerationModel.js";
+export * from "./generateToolCallsOrText.js";

package/tool/index.cjs

@@ -14,14 +14,19 @@ 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("./ExecuteToolEvent.cjs"), exports);
 __exportStar(require("./InvalidToolNameError.cjs"), exports);
-__exportStar(require("./NoSuchToolError.cjs"), exports);
+__exportStar(require("./NoSuchToolDefinitionError.cjs"), exports);
 __exportStar(require("./Tool.cjs"), exports);
+__exportStar(require("./ToolCall.cjs"), exports);
+__exportStar(require("./ToolCallArgumentsValidationError.cjs"), exports);
+__exportStar(require("./ToolCallError.cjs"), exports);
+__exportStar(require("./ToolCallGenerationError.cjs"), exports);
+__exportStar(require("./ToolCallResult.cjs"), exports);
+__exportStar(require("./ToolDefinition.cjs"), exports);
 __exportStar(require("./ToolExecutionError.cjs"), exports);
-__exportStar(require("./UseToolEvent.cjs"), exports);
-__exportStar(require("./UseToolOrGenerateTextEvent.cjs"), exports);
 __exportStar(require("./WebSearchTool.cjs"), exports);
-__exportStar(require("./executeTool.cjs"), exports);
-__exportStar(require("./useTool.cjs"), exports);
-__exportStar(require("./useToolOrGenerateText.cjs"), exports);
+__exportStar(require("./execute-tool/index.cjs"), exports);
+__exportStar(require("./generate-tool-call/index.cjs"), exports);
+__exportStar(require("./generate-tool-calls-or-text/index.cjs"), exports);
+__exportStar(require("./use-tool/index.cjs"), exports);
+__exportStar(require("./use-tools-or-generate-text/index.cjs"), exports);

package/tool/index.d.ts

@@ -1,11 +1,16 @@
-export * from "./ExecuteToolEvent.js";
 export * from "./InvalidToolNameError.js";
-export * from "./NoSuchToolError.js";
+export * from "./NoSuchToolDefinitionError.js";
 export * from "./Tool.js";
+export * from "./ToolCall.js";
+export * from "./ToolCallArgumentsValidationError.js";
+export * from "./ToolCallError.js";
+export * from "./ToolCallGenerationError.js";
+export * from "./ToolCallResult.js";
+export * from "./ToolDefinition.js";
 export * from "./ToolExecutionError.js";
-export * from "./UseToolEvent.js";
-export * from "./UseToolOrGenerateTextEvent.js";
 export * from "./WebSearchTool.js";
-export * from "./executeTool.js";
-export * from "./useTool.js";
-export * from "./useToolOrGenerateText.js";
+export * from "./execute-tool/index.js";
+export * from "./generate-tool-call/index.js";
+export * from "./generate-tool-calls-or-text/index.js";
+export * from "./use-tool/index.js";
+export * from "./use-tools-or-generate-text/index.js";

package/tool/index.js

@@ -1,11 +1,16 @@
-export * from "./ExecuteToolEvent.js";
 export * from "./InvalidToolNameError.js";
-export * from "./NoSuchToolError.js";
+export * from "./NoSuchToolDefinitionError.js";
 export * from "./Tool.js";
+export * from "./ToolCall.js";
+export * from "./ToolCallArgumentsValidationError.js";
+export * from "./ToolCallError.js";
+export * from "./ToolCallGenerationError.js";
+export * from "./ToolCallResult.js";
+export * from "./ToolDefinition.js";
 export * from "./ToolExecutionError.js";
-export * from "./UseToolEvent.js";
-export * from "./UseToolOrGenerateTextEvent.js";
 export * from "./WebSearchTool.js";
-export * from "./executeTool.js";
-export * from "./useTool.js";
-export * from "./useToolOrGenerateText.js";
+export * from "./execute-tool/index.js";
+export * from "./generate-tool-call/index.js";
+export * from "./generate-tool-calls-or-text/index.js";
+export * from "./use-tool/index.js";
+export * from "./use-tools-or-generate-text/index.js";

package/tool/use-tool/UseToolEvent.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/tool/{UseToolEvent.d.ts → use-tool/UseToolEvent.d.ts}

@@ -1,4 +1,4 @@
-import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../../core/FunctionEvent.js";
 export interface UseToolStartedEvent extends BaseFunctionStartedEvent {
     functionType: "use-tool";
 }

package/tool/use-tool/UseToolEvent.js

@@ -0,0 +1 @@
+export {};

package/tool/use-tool/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./UseToolEvent.cjs"), exports);
+__exportStar(require("./useTool.cjs"), exports);

package/tool/use-tool/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UseToolEvent.js";
+export * from "./useTool.js";

package/tool/use-tool/index.js

@@ -0,0 +1,2 @@
+export * from "./UseToolEvent.js";
+export * from "./useTool.js";

package/tool/use-tool/useTool.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTool = void 0;
+const executeFunctionCall_js_1 = require("../../core/executeFunctionCall.cjs");
+const safeExecuteToolCall_js_1 = require("../execute-tool/safeExecuteToolCall.cjs");
+const generateToolCall_js_1 = require("../generate-tool-call/generateToolCall.cjs");
+/**
+ * `useTool` uses `generateToolCall` to generate parameters for a tool and
+ * then executes the tool with the parameters using `executeTool`.
+ *
+ * @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).
+ *
+ * @see {@link generateToolCall}
+ * @see {@link executeTool}
+ */
+async function useTool(model, tool, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tool)
+        : prompt;
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool",
+        execute: async (options) => (0, safeExecuteToolCall_js_1.safeExecuteToolCall)(tool, await (0, generateToolCall_js_1.generateToolCall)(model, tool, expandedPrompt, options), options),
+    });
+}
+exports.useTool = useTool;

package/tool/use-tool/useTool.d.ts

@@ -0,0 +1,16 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Tool } from "../Tool.js";
+import { ToolCallResult } from "../ToolCallResult.js";
+import { ToolCallGenerationModel, ToolCallGenerationModelSettings } from "../generate-tool-call/ToolCallGenerationModel.js";
+/**
+ * `useTool` uses `generateToolCall` to generate parameters for a tool and
+ * then executes the tool with the parameters using `executeTool`.
+ *
+ * @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).
+ *
+ * @see {@link generateToolCall}
+ * @see {@link executeTool}
+ */
+export declare function useTool<PROMPT, TOOL extends Tool<string, any, any>>(model: ToolCallGenerationModel<PROMPT, ToolCallGenerationModelSettings>, tool: TOOL, prompt: PROMPT | ((tool: TOOL) => PROMPT), options?: FunctionOptions): Promise<ToolCallResult<TOOL["name"], TOOL["parameters"], Awaited<ReturnType<TOOL["execute"]>>>>;

package/tool/use-tool/useTool.js

@@ -0,0 +1,26 @@
+import { executeFunctionCall } from "../../core/executeFunctionCall.js";
+import { safeExecuteToolCall } from "../execute-tool/safeExecuteToolCall.js";
+import { generateToolCall } from "../generate-tool-call/generateToolCall.js";
+/**
+ * `useTool` uses `generateToolCall` to generate parameters for a tool and
+ * then executes the tool with the parameters using `executeTool`.
+ *
+ * @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).
+ *
+ * @see {@link generateToolCall}
+ * @see {@link executeTool}
+ */
+export async function useTool(model, tool, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tool)
+        : prompt;
+    return executeFunctionCall({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool",
+        execute: async (options) => safeExecuteToolCall(tool, await generateToolCall(model, tool, expandedPrompt, options), options),
+    });
+}

package/tool/use-tools-or-generate-text/UseToolsOrGenerateTextEvent.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/tool/use-tools-or-generate-text/UseToolsOrGenerateTextEvent.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../../core/FunctionEvent.js";
+export interface UseToolsOrGenerateTextStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "use-tools-or-generate-text";
+}
+export interface UseToolsOrGenerateTextFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "use-tools-or-generate-text";
+}

package/tool/use-tools-or-generate-text/UseToolsOrGenerateTextEvent.js

@@ -0,0 +1 @@
+export {};

package/tool/use-tools-or-generate-text/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./UseToolsOrGenerateTextEvent.cjs"), exports);
+__exportStar(require("./useToolsOrGenerateText.cjs"), exports);

package/tool/use-tools-or-generate-text/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UseToolsOrGenerateTextEvent.js";
+export * from "./useToolsOrGenerateText.js";

package/tool/use-tools-or-generate-text/index.js

@@ -0,0 +1,2 @@
+export * from "./UseToolsOrGenerateTextEvent.js";
+export * from "./useToolsOrGenerateText.js";

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useToolsOrGenerateText = void 0;
+const executeFunctionCall_js_1 = require("../../core/executeFunctionCall.cjs");
+const ToolCallError_js_1 = require("../ToolCallError.cjs");
+const safeExecuteToolCall_js_1 = require("../execute-tool/safeExecuteToolCall.cjs");
+const generateToolCallsOrText_js_1 = require("../generate-tool-calls-or-text/generateToolCallsOrText.cjs");
+async function useToolsOrGenerateText(model, tools, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tools)
+        : prompt;
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tools-or-generate-text",
+        execute: async (options) => {
+            const modelResponse = await (0, generateToolCallsOrText_js_1.generateToolCallsOrText)(model, tools, expandedPrompt, { ...options, returnType: "structure" });
+            const { toolCalls, text } = modelResponse;
+            // no tool calls:
+            if (toolCalls == null) {
+                return { text, toolResults: null };
+            }
+            // execute tools in parallel:
+            const toolResults = await Promise.all(toolCalls.map(async (toolCall) => {
+                const tool = tools.find((tool) => tool.name === toolCall.name);
+                if (tool == null) {
+                    return {
+                        tool: toolCall.name,
+                        toolCall,
+                        args: toolCall.args,
+                        ok: false,
+                        result: new ToolCallError_js_1.ToolCallError({
+                            message: `No tool with name '${toolCall.name}' found.`,
+                            toolCall,
+                        }),
+                    };
+                }
+                return await (0, safeExecuteToolCall_js_1.safeExecuteToolCall)(tool, toolCall, options);
+            }));
+            return {
+                text,
+                toolResults: toolResults,
+            };
+        },
+    });
+}
+exports.useToolsOrGenerateText = useToolsOrGenerateText;

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.d.ts

@@ -0,0 +1,18 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Tool } from "../Tool.js";
+import { ToolCallResult } from "../ToolCallResult.js";
+import { ToolCallsOrTextGenerationModel, ToolCallsOrTextGenerationModelSettings } from "../generate-tool-calls-or-text/ToolCallsOrTextGenerationModel.js";
+type ToolArray<T extends Tool<any, any, any>[]> = T;
+type ToToolMap<T extends ToolArray<Tool<any, any, any>[]>> = {
+    [K in T[number]["name"]]: Extract<T[number], Tool<K, any, any>>;
+};
+type StringKeys<T> = Extract<keyof T, string>;
+type ToToolCallUnion<T> = {
+    [KEY in StringKeys<T>]: T[KEY] extends Tool<any, infer PARAMETERS, infer OUTPUT> ? ToolCallResult<KEY, PARAMETERS, OUTPUT> : never;
+}[StringKeys<T>];
+type ToOutputValue<TOOLS extends ToolArray<Tool<any, any, any>[]>> = ToToolCallUnion<ToToolMap<TOOLS>>;
+export declare function useToolsOrGenerateText<PROMPT, TOOLS extends Array<Tool<any, any, any>>>(model: ToolCallsOrTextGenerationModel<PROMPT, ToolCallsOrTextGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions): Promise<{
+    text: string | null;
+    toolResults: Array<ToOutputValue<TOOLS>> | null;
+}>;
+export {};

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.js

@@ -0,0 +1,44 @@
+import { executeFunctionCall } from "../../core/executeFunctionCall.js";
+import { ToolCallError } from "../ToolCallError.js";
+import { safeExecuteToolCall } from "../execute-tool/safeExecuteToolCall.js";
+import { generateToolCallsOrText } from "../generate-tool-calls-or-text/generateToolCallsOrText.js";
+export async function useToolsOrGenerateText(model, tools, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tools)
+        : prompt;
+    return executeFunctionCall({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tools-or-generate-text",
+        execute: async (options) => {
+            const modelResponse = await generateToolCallsOrText(model, tools, expandedPrompt, { ...options, returnType: "structure" });
+            const { toolCalls, text } = modelResponse;
+            // no tool calls:
+            if (toolCalls == null) {
+                return { text, toolResults: null };
+            }
+            // execute tools in parallel:
+            const toolResults = await Promise.all(toolCalls.map(async (toolCall) => {
+                const tool = tools.find((tool) => tool.name === toolCall.name);
+                if (tool == null) {
+                    return {
+                        tool: toolCall.name,
+                        toolCall,
+                        args: toolCall.args,
+                        ok: false,
+                        result: new ToolCallError({
+                            message: `No tool with name '${toolCall.name}' found.`,
+                            toolCall,
+                        }),
+                    };
+                }
+                return await safeExecuteToolCall(tool, toolCall, options);
+            }));
+            return {
+                text,
+                toolResults: toolResults,
+            };
+        },
+    });
+}

package/util/getErrorMessage.cjs

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getErrorMessage = void 0;
 function getErrorMessage(error) {
+    if (error == null) {
+        return "unknown error";
+    }
     if (typeof error === "string") {
         return error;
     }

package/util/getErrorMessage.d.ts

@@ -1 +1 @@
-export declare function getErrorMessage(error: unknown): string;
+export declare function getErrorMessage(error: unknown | undefined): string;

package/util/getErrorMessage.js

@@ -1,4 +1,7 @@
 export function getErrorMessage(error) {
+    if (error == null) {
+        return "unknown error";
+    }
     if (typeof error === "string") {
         return error;
     }

package/model-function/generate-structure/NoSuchStructureError.cjs

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoSuchStructureError = void 0;
-class NoSuchStructureError extends Error {
-    constructor(structureName) {
-        super(`No such structure: ${structureName}`);
-        Object.defineProperty(this, "structureName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "NoSuchStructureError";
-        this.structureName = structureName;
-    }
-}
-exports.NoSuchStructureError = NoSuchStructureError;

package/model-function/generate-structure/NoSuchStructureError.d.ts

@@ -1,4 +0,0 @@
-export declare class NoSuchStructureError extends Error {
-    readonly structureName: string;
-    constructor(structureName: string);
-}

package/model-function/generate-structure/NoSuchStructureError.js

@@ -1,13 +0,0 @@
-export class NoSuchStructureError extends Error {
-    constructor(structureName) {
-        super(`No such structure: ${structureName}`);
-        Object.defineProperty(this, "structureName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "NoSuchStructureError";
-        this.structureName = structureName;
-    }
-}

package/model-function/generate-structure/StructureOrTextGenerationModel.d.ts

@@ -1,26 +0,0 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { StructureDefinition } from "../../core/schema/StructureDefinition.js";
-import { Model, ModelSettings } from "../Model.js";
-export interface StructureOrTextGenerationModelSettings extends ModelSettings {
-}
-export interface StructureOrTextGenerationModel<PROMPT, SETTINGS extends StructureOrTextGenerationModelSettings> extends Model<SETTINGS> {
-    doGenerateStructureOrText(structureDefinitions: Array<StructureDefinition<string, unknown>>, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
-        response: unknown;
-        structureAndText: {
-            structure: null;
-            value: null;
-            valueText: null;
-            text: string;
-        } | {
-            structure: string;
-            value: unknown;
-            valueText: string;
-            text: string | null;
-        };
-        usage?: {
-            promptTokens: number;
-            completionTokens: number;
-            totalTokens: number;
-        };
-    }>;
-}

package/model-function/generate-structure/generateStructureOrText.cjs

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStructureOrText = void 0;
-const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-const NoSuchStructureError_js_1 = require("./NoSuchStructureError.cjs");
-const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
-async function generateStructureOrText(model, structureDefinitions, prompt, options) {
-    // Note: PROMPT must not be a function.
-    const expandedPrompt = typeof prompt === "function"
-        ? prompt(structureDefinitions)
-        : prompt;
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "generate-structure-or-text",
-        input: expandedPrompt,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doGenerateStructureOrText(structureDefinitions, expandedPrompt, options);
-            const { structure, value, text } = result.structureAndText;
-            // text generation:
-            if (structure == null) {
-                return {
-                    response: result.response,
-                    extractedValue: { structure, value, text },
-                    usage: result.usage,
-                };
-            }
-            const definition = structureDefinitions.find((d) => d.name === structure);
-            if (definition == undefined) {
-                throw new NoSuchStructureError_js_1.NoSuchStructureError(structure);
-            }
-            const parseResult = definition.schema.validate(value);
-            if (!parseResult.success) {
-                throw new StructureValidationError_js_1.StructureValidationError({
-                    structureName: structure,
-                    value,
-                    valueText: result.structureAndText.valueText,
-                    cause: parseResult.error,
-                });
-            }
-            return {
-                response: result.response,
-                extractedValue: {
-                    structure: structure,
-                    value: parseResult.data,
-                    text: text, // text is string | null, which is part of the response for schema values
-                },
-                usage: result.usage,
-            };
-        },
-    });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
-}
-exports.generateStructureOrText = generateStructureOrText;