modelfusion 0.7.0 → 0.8.0

package/run/DefaultRun.cjs

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultRun = void 0;
 const nanoid_1 = require("nanoid");
-const SuccessfulModelCall_js_1 = require("../model-function/SuccessfulModelCall.cjs");
 const calculateCost_js_1 = require("../cost/calculateCost.cjs");
+const SuccessfulModelCall_js_1 = require("../model-function/SuccessfulModelCall.cjs");
 class DefaultRun {
     constructor({ runId = (0, nanoid_1.nanoid)(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
         Object.defineProperty(this, "runId", {
@@ -36,7 +36,7 @@ class DefaultRun {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modelCallEvents", {
+        Object.defineProperty(this, "events", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -55,18 +55,18 @@ class DefaultRun {
         this.costCalculators = costCalculators;
         this.observers = [
             {
-                onModelCallStarted: (event) => {
-                    this.modelCallEvents.push(event);
+                onRunFunctionStarted: (event) => {
+                    this.events.push(event);
                 },
-                onModelCallFinished: (event) => {
-                    this.modelCallEvents.push(event);
+                onRunFunctionFinished: (event) => {
+                    this.events.push(event);
                 },
             },
             ...(observers ?? []),
         ];
     }
     get successfulModelCalls() {
-        return (0, SuccessfulModelCall_js_1.extractSuccessfulModelCalls)(this.modelCallEvents);
+        return (0, SuccessfulModelCall_js_1.extractSuccessfulModelCalls)(this.events);
     }
     calculateCost() {
         return (0, calculateCost_js_1.calculateCost)({

package/run/DefaultRun.d.ts

@@ -1,22 +1,22 @@
+import { CostCalculator } from "../cost/CostCalculator.js";
 import { SuccessfulModelCall } from "../model-function/SuccessfulModelCall.js";
-import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
-import { ModelCallObserver } from "../model-function/ModelCallObserver.js";
 import { Run } from "./Run.js";
-import { CostCalculator } from "../cost/CostCalculator.js";
+import { RunFunctionEvent } from "./RunFunctionEvent.js";
+import { RunFunctionObserver } from "./RunFunctionObserver.js";
 export declare class DefaultRun implements Run {
     readonly runId: string;
     readonly sessionId?: string;
     readonly userId?: string;
     readonly abortSignal?: AbortSignal;
     readonly costCalculators: CostCalculator[];
-    readonly modelCallEvents: (ModelCallFinishedEvent | ModelCallStartedEvent)[];
-    readonly observers?: ModelCallObserver[];
+    readonly events: RunFunctionEvent[];
+    readonly observers?: RunFunctionObserver[];
     constructor({ runId, sessionId, userId, abortSignal, observers, costCalculators, }?: {
         runId?: string;
         sessionId?: string;
         userId?: string;
         abortSignal?: AbortSignal;
-        observers?: ModelCallObserver[];
+        observers?: RunFunctionObserver[];
         costCalculators?: CostCalculator[];
     });
     get successfulModelCalls(): Array<SuccessfulModelCall>;

package/run/DefaultRun.js

@@ -1,6 +1,6 @@
 import { nanoid as createId } from "nanoid";
-import { extractSuccessfulModelCalls, } from "../model-function/SuccessfulModelCall.js";
 import { calculateCost } from "../cost/calculateCost.js";
+import { extractSuccessfulModelCalls, } from "../model-function/SuccessfulModelCall.js";
 export class DefaultRun {
     constructor({ runId = createId(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
         Object.defineProperty(this, "runId", {
@@ -33,7 +33,7 @@ export class DefaultRun {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modelCallEvents", {
+        Object.defineProperty(this, "events", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -52,18 +52,18 @@ export class DefaultRun {
         this.costCalculators = costCalculators;
         this.observers = [
             {
-                onModelCallStarted: (event) => {
-                    this.modelCallEvents.push(event);
+                onRunFunctionStarted: (event) => {
+                    this.events.push(event);
                 },
-                onModelCallFinished: (event) => {
-                    this.modelCallEvents.push(event);
+                onRunFunctionFinished: (event) => {
+                    this.events.push(event);
                 },
             },
             ...(observers ?? []),
         ];
     }
     get successfulModelCalls() {
-        return extractSuccessfulModelCalls(this.modelCallEvents);
+        return extractSuccessfulModelCalls(this.events);
     }
     calculateCost() {
         return calculateCost({

package/run/Run.d.ts

@@ -1,5 +1,5 @@
 import { ErrorHandler } from "../util/ErrorHandler.js";
-import { ModelCallObserver } from "../model-function/ModelCallObserver.js";
+import { RunFunctionObserver } from "./RunFunctionObserver.js";
 export interface Run {
     /**
      * Unique identifier for a specific run. Primarily utilized for efficient referencing
@@ -22,6 +22,6 @@ export interface Run {
      * to the run.
      */
     abortSignal?: AbortSignal;
-    observers?: ModelCallObserver[];
+    observers?: RunFunctionObserver[];
     errorHandler?: ErrorHandler;
 }

package/run/RunFunction.d.ts

@@ -1,4 +1,3 @@
-import { SafeResult } from "../util/SafeResult.js";
 import { Run } from "./Run.js";
 /**
  * Standardized function signature for functions that are part of a run.
@@ -8,6 +7,3 @@ import { Run } from "./Run.js";
 export type RunFunction<INPUT, OUTPUT> = (input: INPUT, options?: {
     run?: Run;
 }) => PromiseLike<OUTPUT>;
-export type SafeRunFunction<INPUT, OUTPUT> = (input: INPUT, options?: {
-    run?: Run;
-}) => PromiseLike<SafeResult<OUTPUT>>;

package/run/RunFunctionEvent.d.ts

@@ -0,0 +1,12 @@
+import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "tool/ExecuteToolEvent.js";
+import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
+import { IdMetadata } from "./IdMetadata.js";
+export type RunFunctionEvent = RunFunctionStartedEvent | RunFunctionFinishedEvent;
+export type RunFunctionStartedEventMetadata = IdMetadata & {
+    startEpochSeconds: number;
+};
+export type RunFunctionStartedEvent = ModelCallStartedEvent | ExecuteToolStartedEvent;
+export type RunFunctionFinishedEventMetadata = RunFunctionStartedEventMetadata & {
+    durationInMs: number;
+};
+export type RunFunctionFinishedEvent = ModelCallFinishedEvent | ExecuteToolFinishedEvent;

package/{model-function/ModelCallEventSource.cjs → run/RunFunctionEventSource.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelCallEventSource = void 0;
-class ModelCallEventSource {
+exports.RunFunctionEventSource = void 0;
+class RunFunctionEventSource {
     constructor({ observers, errorHandler, }) {
         Object.defineProperty(this, "observers", {
             enumerable: true,
@@ -18,20 +18,20 @@ class ModelCallEventSource {
         this.observers = observers;
         this.errorHandler = errorHandler ?? ((error) => console.error(error));
     }
-    notifyModelCallStarted(event) {
+    notifyRunFunctionStarted(event) {
         for (const observer of this.observers) {
             try {
-                observer.onModelCallStarted?.(event);
+                observer.onRunFunctionStarted?.(event);
             }
             catch (error) {
                 this.errorHandler(error);
             }
         }
     }
-    notifyModelCallFinished(event) {
+    notifyRunFunctionFinished(event) {
         for (const observer of this.observers) {
             try {
-                observer.onModelCallFinished?.(event);
+                observer.onRunFunctionFinished?.(event);
             }
             catch (error) {
                 this.errorHandler(error);
@@ -39,4 +39,4 @@ class ModelCallEventSource {
         }
     }
 }
-exports.ModelCallEventSource = ModelCallEventSource;
+exports.RunFunctionEventSource = RunFunctionEventSource;

package/run/RunFunctionEventSource.d.ts

@@ -0,0 +1,13 @@
+import { ErrorHandler } from "../util/ErrorHandler.js";
+import { RunFunctionFinishedEvent, RunFunctionStartedEvent } from "./RunFunctionEvent.js";
+import { RunFunctionObserver } from "./RunFunctionObserver.js";
+export declare class RunFunctionEventSource {
+    readonly observers: RunFunctionObserver[];
+    readonly errorHandler: ErrorHandler;
+    constructor({ observers, errorHandler, }: {
+        observers: RunFunctionObserver[];
+        errorHandler?: ErrorHandler;
+    });
+    notifyRunFunctionStarted(event: RunFunctionStartedEvent): void;
+    notifyRunFunctionFinished(event: RunFunctionFinishedEvent): void;
+}

package/{model-function/ModelCallEventSource.js → run/RunFunctionEventSource.js}

@@ -1,4 +1,4 @@
-export class ModelCallEventSource {
+export class RunFunctionEventSource {
     constructor({ observers, errorHandler, }) {
         Object.defineProperty(this, "observers", {
             enumerable: true,
@@ -15,20 +15,20 @@ export class ModelCallEventSource {
         this.observers = observers;
         this.errorHandler = errorHandler ?? ((error) => console.error(error));
     }
-    notifyModelCallStarted(event) {
+    notifyRunFunctionStarted(event) {
         for (const observer of this.observers) {
             try {
-                observer.onModelCallStarted?.(event);
+                observer.onRunFunctionStarted?.(event);
             }
             catch (error) {
                 this.errorHandler(error);
             }
         }
     }
-    notifyModelCallFinished(event) {
+    notifyRunFunctionFinished(event) {
         for (const observer of this.observers) {
             try {
-                observer.onModelCallFinished?.(event);
+                observer.onRunFunctionFinished?.(event);
             }
             catch (error) {
                 this.errorHandler(error);

package/run/RunFunctionObserver.cjs

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

package/run/RunFunctionObserver.d.ts

@@ -0,0 +1,5 @@
+import { RunFunctionFinishedEvent, RunFunctionStartedEvent } from "./RunFunctionEvent.js";
+export type RunFunctionObserver = {
+    onRunFunctionStarted?: (event: RunFunctionStartedEvent) => void;
+    onRunFunctionFinished?: (event: RunFunctionFinishedEvent) => void;
+};

package/run/RunFunctionObserver.js

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

package/run/index.cjs

@@ -19,4 +19,7 @@ __exportStar(require("./DefaultRun.cjs"), exports);
 __exportStar(require("./IdMetadata.cjs"), exports);
 __exportStar(require("./Run.cjs"), exports);
 __exportStar(require("./RunFunction.cjs"), exports);
+__exportStar(require("./RunFunctionEvent.cjs"), exports);
+__exportStar(require("./RunFunctionObserver.cjs"), exports);
+__exportStar(require("./RunFunctionEventSource.cjs"), exports);
 __exportStar(require("./Vector.cjs"), exports);

package/run/index.d.ts

@@ -3,4 +3,7 @@ export * from "./DefaultRun.js";
 export * from "./IdMetadata.js";
 export * from "./Run.js";
 export * from "./RunFunction.js";
+export * from "./RunFunctionEvent.js";
+export * from "./RunFunctionObserver.js";
+export * from "./RunFunctionEventSource.js";
 export * from "./Vector.js";

package/run/index.js

@@ -3,4 +3,7 @@ export * from "./DefaultRun.js";
 export * from "./IdMetadata.js";
 export * from "./Run.js";
 export * from "./RunFunction.js";
+export * from "./RunFunctionEvent.js";
+export * from "./RunFunctionObserver.js";
+export * from "./RunFunctionEventSource.js";
 export * from "./Vector.js";

package/tool/ExecuteToolEvent.cjs

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

package/tool/ExecuteToolEvent.d.ts

@@ -0,0 +1,22 @@
+import { RunFunctionFinishedEventMetadata, RunFunctionStartedEventMetadata } from "../run/RunFunctionEvent.js";
+import { Tool } from "./Tool.js";
+export type ExecuteToolStartedEvent = {
+    type: "execute-tool-started";
+    metadata: RunFunctionStartedEventMetadata;
+    tool: Tool<string, unknown, unknown>;
+    input: unknown;
+};
+export type ExecuteToolFinishedEvent = {
+    type: "execute-tool-finished";
+    metadata: RunFunctionFinishedEventMetadata;
+    tool: Tool<string, unknown, unknown>;
+    input: unknown;
+} & ({
+    status: "success";
+    output: unknown;
+} | {
+    status: "failure";
+    error: unknown;
+} | {
+    status: "abort";
+});

package/tool/ExecuteToolEvent.js

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

package/{composed-function/use-tool → tool}/Tool.cjs

@@ -21,6 +21,12 @@ class Tool {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "outputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "execute", {
             enumerable: true,
             configurable: true,
@@ -30,6 +36,7 @@ class Tool {
         this.name = options.name;
         this.description = options.description;
         this.inputSchema = options.inputSchema;
+        this.outputSchema = options.outputSchema;
         this.execute = options.execute;
     }
     get inputSchemaDefinition() {

package/{composed-function/use-tool → tool}/Tool.d.ts

@@ -1,14 +1,17 @@
 import { z } from "zod";
-import { SchemaDefinition } from "../../model-function/generate-json/SchemaDefinition.js";
+import { SchemaDefinition } from "../model-function/generate-json/SchemaDefinition.js";
+import { RunFunction } from "../run/RunFunction.js";
 export declare class Tool<NAME extends string, INPUT, OUTPUT> {
     readonly name: NAME;
     readonly description: string;
     readonly inputSchema: z.ZodSchema<INPUT>;
-    readonly execute: (input: INPUT) => PromiseLike<OUTPUT>;
+    readonly outputSchema?: z.ZodSchema<OUTPUT>;
+    readonly execute: RunFunction<INPUT, OUTPUT>;
     constructor(options: {
         name: NAME;
         description: string;
         inputSchema: z.ZodSchema<INPUT>;
+        outputSchema?: z.ZodSchema<OUTPUT>;
         execute(input: INPUT): Promise<OUTPUT>;
     });
     get inputSchemaDefinition(): SchemaDefinition<NAME, INPUT>;

package/{composed-function/use-tool → tool}/Tool.js

@@ -18,6 +18,12 @@ export class Tool {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "outputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "execute", {
             enumerable: true,
             configurable: true,
@@ -27,6 +33,7 @@ export class Tool {
         this.name = options.name;
         this.description = options.description;
         this.inputSchema = options.inputSchema;
+        this.outputSchema = options.outputSchema;
         this.execute = options.execute;
     }
     get inputSchemaDefinition() {

package/tool/ToolExecutionError.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutionError = void 0;
+class ToolExecutionError extends Error {
+    constructor({ message = "unknown error", toolName, input, cause, }) {
+        super(`Error executing tool ${toolName}: ${message}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolExecutionError";
+        this.toolName = toolName;
+        this.input = input;
+        this.cause = cause;
+    }
+}
+exports.ToolExecutionError = ToolExecutionError;

package/tool/ToolExecutionError.d.ts

@@ -0,0 +1,11 @@
+export declare class ToolExecutionError extends Error {
+    readonly toolName: string;
+    readonly input: unknown;
+    readonly cause: unknown;
+    constructor({ message, toolName, input, cause, }: {
+        toolName: string;
+        input: unknown;
+        message: string | undefined;
+        cause: unknown | undefined;
+    });
+}

package/tool/ToolExecutionError.js

@@ -0,0 +1,27 @@
+export class ToolExecutionError extends Error {
+    constructor({ message = "unknown error", toolName, input, cause, }) {
+        super(`Error executing tool ${toolName}: ${message}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolExecutionError";
+        this.toolName = toolName;
+        this.input = input;
+        this.cause = cause;
+    }
+}

package/tool/executeTool.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTool = void 0;
+const nanoid_1 = require("nanoid");
+const RunFunctionEventSource_js_1 = require("../run/RunFunctionEventSource.cjs");
+const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
+const AbortError_js_1 = require("../util/api/AbortError.cjs");
+const runSafe_js_1 = require("../util/runSafe.cjs");
+const ToolExecutionError_js_1 = require("./ToolExecutionError.cjs");
+async function executeTool(tool, input, options) {
+    const run = options?.run;
+    const eventSource = new RunFunctionEventSource_js_1.RunFunctionEventSource({
+        observers: run?.observers ?? [],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
+    const startMetadata = {
+        callId: `call-${(0, nanoid_1.nanoid)()}`,
+        runId: run?.runId,
+        sessionId: run?.sessionId,
+        userId: run?.userId,
+        functionId: options?.functionId,
+        startEpochSeconds: durationMeasurement.startEpochSeconds,
+    };
+    eventSource.notifyRunFunctionStarted({
+        type: "execute-tool-started",
+        metadata: startMetadata,
+        tool: tool,
+        input,
+    });
+    const result = await (0, runSafe_js_1.runSafe)(() => tool.execute(input, options));
+    const finishMetadata = {
+        ...startMetadata,
+        durationInMs: durationMeasurement.durationInMs,
+    };
+    if (!result.ok) {
+        if (result.isAborted) {
+            eventSource.notifyRunFunctionFinished({
+                type: "execute-tool-finished",
+                status: "abort",
+                metadata: finishMetadata,
+                tool: tool,
+                input,
+            });
+            throw new AbortError_js_1.AbortError();
+        }
+        eventSource.notifyRunFunctionFinished({
+            type: "execute-tool-finished",
+            status: "failure",
+            metadata: finishMetadata,
+            tool: tool,
+            input,
+            error: result.error,
+        });
+        throw new ToolExecutionError_js_1.ToolExecutionError({
+            toolName: tool.name,
+            input,
+            cause: result.error,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            message: result.error?.message,
+        });
+    }
+    const output = result.output;
+    eventSource.notifyRunFunctionFinished({
+        type: "execute-tool-finished",
+        status: "success",
+        metadata: finishMetadata,
+        tool: tool,
+        input,
+        output,
+    });
+    return options?.fullResponse === true
+        ? {
+            output,
+            metadata: finishMetadata,
+        }
+        : output;
+}
+exports.executeTool = executeTool;

package/tool/executeTool.d.ts

@@ -0,0 +1,20 @@
+import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { Tool } from "./Tool.js";
+export type ExecuteToolMetadata = {
+    callId: string;
+    runId?: string;
+    sessionId?: string;
+    userId?: string;
+    functionId?: string;
+    startEpochSeconds: number;
+    durationInMs: number;
+};
+export declare function executeTool<INPUT, OUTPUT>(tool: Tool<string, INPUT, OUTPUT>, input: INPUT, options: FunctionOptions<undefined> & {
+    fullResponse: true;
+}): Promise<{
+    output: OUTPUT;
+    metadata: ExecuteToolMetadata;
+}>;
+export declare function executeTool<INPUT, OUTPUT>(tool: Tool<string, INPUT, OUTPUT>, input: INPUT, options?: FunctionOptions<undefined> & {
+    fullResponse?: false;
+}): Promise<OUTPUT>;

package/tool/executeTool.js

@@ -0,0 +1,75 @@
+import { nanoid as createId } from "nanoid";
+import { RunFunctionEventSource } from "../run/RunFunctionEventSource.js";
+import { startDurationMeasurement } from "../util/DurationMeasurement.js";
+import { AbortError } from "../util/api/AbortError.js";
+import { runSafe } from "../util/runSafe.js";
+import { ToolExecutionError } from "./ToolExecutionError.js";
+export async function executeTool(tool, input, options) {
+    const run = options?.run;
+    const eventSource = new RunFunctionEventSource({
+        observers: run?.observers ?? [],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = startDurationMeasurement();
+    const startMetadata = {
+        callId: `call-${createId()}`,
+        runId: run?.runId,
+        sessionId: run?.sessionId,
+        userId: run?.userId,
+        functionId: options?.functionId,
+        startEpochSeconds: durationMeasurement.startEpochSeconds,
+    };
+    eventSource.notifyRunFunctionStarted({
+        type: "execute-tool-started",
+        metadata: startMetadata,
+        tool: tool,
+        input,
+    });
+    const result = await runSafe(() => tool.execute(input, options));
+    const finishMetadata = {
+        ...startMetadata,
+        durationInMs: durationMeasurement.durationInMs,
+    };
+    if (!result.ok) {
+        if (result.isAborted) {
+            eventSource.notifyRunFunctionFinished({
+                type: "execute-tool-finished",
+                status: "abort",
+                metadata: finishMetadata,
+                tool: tool,
+                input,
+            });
+            throw new AbortError();
+        }
+        eventSource.notifyRunFunctionFinished({
+            type: "execute-tool-finished",
+            status: "failure",
+            metadata: finishMetadata,
+            tool: tool,
+            input,
+            error: result.error,
+        });
+        throw new ToolExecutionError({
+            toolName: tool.name,
+            input,
+            cause: result.error,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            message: result.error?.message,
+        });
+    }
+    const output = result.output;
+    eventSource.notifyRunFunctionFinished({
+        type: "execute-tool-finished",
+        status: "success",
+        metadata: finishMetadata,
+        tool: tool,
+        input,
+        output,
+    });
+    return options?.fullResponse === true
+        ? {
+            output,
+            metadata: finishMetadata,
+        }
+        : output;
+}

package/tool/index.cjs

@@ -0,0 +1,22 @@
+"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("./NoSuchToolError.cjs"), exports);
+__exportStar(require("./Tool.cjs"), exports);
+__exportStar(require("./ToolExecutionError.cjs"), exports);
+__exportStar(require("./executeTool.cjs"), exports);
+__exportStar(require("./useTool.cjs"), exports);
+__exportStar(require("./useToolOrGenerateText.cjs"), exports);

package/tool/index.d.ts

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