modelfusion 0.0.44

package/composed-function/use-tool/NoSuchToolError.js

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

package/composed-function/use-tool/Tool.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tool = void 0;
+class Tool {
+    constructor(options) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "execute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = options.name;
+        this.description = options.description;
+        this.inputSchema = options.inputSchema;
+        this.execute = options.execute;
+    }
+    get inputSchemaDefinition() {
+        return {
+            name: this.name,
+            description: this.description,
+            schema: this.inputSchema,
+        };
+    }
+}
+exports.Tool = Tool;

package/composed-function/use-tool/Tool.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { SchemaDefinition } from "../../model-function/generate-json/SchemaDefinition.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>;
+    constructor(options: {
+        name: NAME;
+        description: string;
+        inputSchema: z.ZodSchema<INPUT>;
+        execute(input: INPUT): Promise<OUTPUT>;
+    });
+    get inputSchemaDefinition(): SchemaDefinition<NAME, INPUT>;
+}

package/composed-function/use-tool/Tool.js

@@ -0,0 +1,39 @@
+export class Tool {
+    constructor(options) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "execute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = options.name;
+        this.description = options.description;
+        this.inputSchema = options.inputSchema;
+        this.execute = options.execute;
+    }
+    get inputSchemaDefinition() {
+        return {
+            name: this.name,
+            description: this.description,
+            schema: this.inputSchema,
+        };
+    }
+}

package/composed-function/use-tool/useTool.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useToolOrGenerateText = exports.useTool = void 0;
+const generateJson_js_1 = require("../../model-function/generate-json/generateJson.cjs");
+const generateJsonOrText_js_1 = require("../../model-function/generate-json/generateJsonOrText.cjs");
+const NoSuchToolError_js_1 = require("./NoSuchToolError.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.
+ *
+ * @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 { value } = await (0, generateJson_js_1.generateJson)(model, {
+        name: tool.name,
+        description: tool.description,
+        schema: tool.inputSchema,
+    }, () => prompt(tool), options);
+    return {
+        tool: tool.name,
+        parameters: value,
+        result: await tool.execute(value),
+    };
+}
+exports.useTool = useTool;
+async function useToolOrGenerateText(model, tools, prompt, options) {
+    const expandedPrompt = prompt(tools);
+    const modelResponse = await (0, generateJsonOrText_js_1.generateJsonOrText)(model, tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        schema: tool.inputSchema,
+    })), () => expandedPrompt, options);
+    const { schema, text } = modelResponse;
+    if (schema == null) {
+        return {
+            tool: null,
+            parameters: null,
+            result: null,
+            text,
+        };
+    }
+    const tool = tools.find((tool) => tool.name === schema);
+    if (tool == null) {
+        throw new NoSuchToolError_js_1.NoSuchToolError(schema.toString());
+    }
+    const toolParameters = modelResponse.value;
+    const result = await tool.execute(toolParameters);
+    return {
+        tool: schema,
+        result,
+        parameters: toolParameters,
+        text: text, // string | null is the expected value here
+    };
+}
+exports.useToolOrGenerateText = useToolOrGenerateText;

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

@@ -0,0 +1,36 @@
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { GenerateJsonModel, GenerateJsonModelSettings, GenerateJsonPrompt } from "../../model-function/generate-json/GenerateJsonModel.js";
+import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "../../model-function/generate-json/GenerateJsonOrTextModel.js";
+import { Tool } from "./Tool.js";
+/**
+ * `useTool` uses `generateJson` 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 GenerateJsonModelSettings, TOOL extends Tool<any, any, any>>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, tool: TOOL, prompt: (tool: TOOL) => PROMPT & GenerateJsonPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): Promise<{
+    tool: TOOL["name"];
+    parameters: TOOL["inputSchema"];
+    result: Awaited<ReturnType<TOOL["execute"]>>;
+}>;
+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 ToToolUnion<T> = {
+    [KEY in keyof T]: T[KEY] extends Tool<any, infer INPUT, infer OUTPUT> ? {
+        tool: KEY;
+        parameters: INPUT;
+        result: OUTPUT;
+        text: string | null;
+    } : never;
+}[keyof T];
+type ToOutputValue<TOOLS extends ToolArray<Tool<any, any, any>[]>> = ToToolUnion<ToToolMap<TOOLS>>;
+export declare function useToolOrGenerateText<PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings, TOOLS extends Array<Tool<any, any, any>>>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, tools: TOOLS, prompt: (tools: TOOLS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): Promise<{
+    tool: null;
+    parameters: null;
+    result: null;
+    text: string;
+} | ToOutputValue<TOOLS>>;
+export {};

package/composed-function/use-tool/useTool.js

@@ -0,0 +1,54 @@
+import { generateJson } from "../../model-function/generate-json/generateJson.js";
+import { generateJsonOrText } from "../../model-function/generate-json/generateJsonOrText.js";
+import { NoSuchToolError } from "./NoSuchToolError.js";
+// 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.
+ *
+ * @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 async function useTool(model, tool, prompt, options) {
+    const { value } = await generateJson(model, {
+        name: tool.name,
+        description: tool.description,
+        schema: tool.inputSchema,
+    }, () => prompt(tool), options);
+    return {
+        tool: tool.name,
+        parameters: value,
+        result: await tool.execute(value),
+    };
+}
+export async function useToolOrGenerateText(model, tools, prompt, options) {
+    const expandedPrompt = prompt(tools);
+    const modelResponse = await generateJsonOrText(model, tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        schema: tool.inputSchema,
+    })), () => expandedPrompt, options);
+    const { schema, text } = modelResponse;
+    if (schema == null) {
+        return {
+            tool: null,
+            parameters: null,
+            result: null,
+            text,
+        };
+    }
+    const tool = tools.find((tool) => tool.name === schema);
+    if (tool == null) {
+        throw new NoSuchToolError(schema.toString());
+    }
+    const toolParameters = modelResponse.value;
+    const result = await tool.execute(toolParameters);
+    return {
+        tool: schema,
+        result,
+        parameters: toolParameters,
+        text: text, // string | null is the expected value here
+    };
+}

package/cost/Cost.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cost = void 0;
+class Cost {
+    constructor({ costInMillicents, hasUnknownCost, callsWithUnknownCost, }) {
+        Object.defineProperty(this, "costInMillicents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hasUnknownCost", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "callsWithUnknownCost", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.costInMillicents = costInMillicents;
+        this.hasUnknownCost = hasUnknownCost;
+        this.callsWithUnknownCost = callsWithUnknownCost;
+    }
+    get costInCent() {
+        return this.costInMillicents / 1000;
+    }
+    get costInDollar() {
+        return this.costInCent / 100;
+    }
+    formatAsDollarAmount({ decimals = 2 } = {}) {
+        return `$${this.costInDollar.toFixed(decimals)}`;
+    }
+}
+exports.Cost = Cost;

package/cost/Cost.d.ts

@@ -0,0 +1,16 @@
+import { SuccessfulModelCall } from "../model-function/SuccessfulModelCall.js";
+export declare class Cost {
+    readonly costInMillicents: number;
+    readonly hasUnknownCost: boolean;
+    readonly callsWithUnknownCost: SuccessfulModelCall[];
+    constructor({ costInMillicents, hasUnknownCost, callsWithUnknownCost, }: {
+        costInMillicents: number;
+        hasUnknownCost: boolean;
+        callsWithUnknownCost: SuccessfulModelCall[];
+    });
+    get costInCent(): number;
+    get costInDollar(): number;
+    formatAsDollarAmount({ decimals }?: {
+        decimals?: number;
+    }): string;
+}

package/cost/Cost.js

@@ -0,0 +1,34 @@
+export class Cost {
+    constructor({ costInMillicents, hasUnknownCost, callsWithUnknownCost, }) {
+        Object.defineProperty(this, "costInMillicents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hasUnknownCost", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "callsWithUnknownCost", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.costInMillicents = costInMillicents;
+        this.hasUnknownCost = hasUnknownCost;
+        this.callsWithUnknownCost = callsWithUnknownCost;
+    }
+    get costInCent() {
+        return this.costInMillicents / 1000;
+    }
+    get costInDollar() {
+        return this.costInCent / 100;
+    }
+    formatAsDollarAmount({ decimals = 2 } = {}) {
+        return `$${this.costInDollar.toFixed(decimals)}`;
+    }
+}

package/cost/CostCalculator.cjs

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

package/cost/CostCalculator.d.ts

@@ -0,0 +1,8 @@
+import { SuccessfulModelCall } from "../model-function/SuccessfulModelCall.js";
+export interface CostCalculator {
+    readonly provider: string;
+    /**
+     * @return null if the cost is unknown, otherwise the cost in Millicents (0 if free)
+     */
+    calculateCostInMillicents(call: SuccessfulModelCall): PromiseLike<number | null>;
+}

package/cost/CostCalculator.js

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

package/cost/calculateCost.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateCost = void 0;
+const Cost_js_1 = require("./Cost.cjs");
+async function calculateCost({ calls, costCalculators, }) {
+    let costInMillicents = 0;
+    const callsWithUnknownCost = [];
+    for (const call of calls) {
+        const model = call.model;
+        const providerCostCalculator = costCalculators.find((providerCostCalculator) => providerCostCalculator.provider === model.provider);
+        if (!providerCostCalculator) {
+            callsWithUnknownCost.push(call);
+            continue;
+        }
+        const cost = await providerCostCalculator.calculateCostInMillicents(call);
+        if (cost === null) {
+            callsWithUnknownCost.push(call);
+            continue;
+        }
+        costInMillicents += cost;
+    }
+    return new Cost_js_1.Cost({
+        costInMillicents,
+        hasUnknownCost: callsWithUnknownCost.length > 0,
+        callsWithUnknownCost,
+    });
+}
+exports.calculateCost = calculateCost;

package/cost/calculateCost.d.ts

@@ -0,0 +1,7 @@
+import { Cost } from "./Cost.js";
+import { CostCalculator } from "./CostCalculator.js";
+import { SuccessfulModelCall } from "../model-function/SuccessfulModelCall.js";
+export declare function calculateCost({ calls, costCalculators, }: {
+    calls: SuccessfulModelCall[];
+    costCalculators: CostCalculator[];
+}): Promise<Cost>;

package/cost/calculateCost.js

@@ -0,0 +1,24 @@
+import { Cost } from "./Cost.js";
+export async function calculateCost({ calls, costCalculators, }) {
+    let costInMillicents = 0;
+    const callsWithUnknownCost = [];
+    for (const call of calls) {
+        const model = call.model;
+        const providerCostCalculator = costCalculators.find((providerCostCalculator) => providerCostCalculator.provider === model.provider);
+        if (!providerCostCalculator) {
+            callsWithUnknownCost.push(call);
+            continue;
+        }
+        const cost = await providerCostCalculator.calculateCostInMillicents(call);
+        if (cost === null) {
+            callsWithUnknownCost.push(call);
+            continue;
+        }
+        costInMillicents += cost;
+    }
+    return new Cost({
+        costInMillicents,
+        hasUnknownCost: callsWithUnknownCost.length > 0,
+        callsWithUnknownCost,
+    });
+}

package/cost/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("./Cost.cjs"), exports);
+__exportStar(require("./calculateCost.cjs"), exports);
+__exportStar(require("./CostCalculator.cjs"), exports);

package/cost/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Cost.js";
+export * from "./calculateCost.js";
+export * from "./CostCalculator.js";

package/cost/index.js

@@ -0,0 +1,3 @@
+export * from "./Cost.js";
+export * from "./calculateCost.js";
+export * from "./CostCalculator.js";

package/index.cjs

@@ -0,0 +1,25 @@
+"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("./composed-function/index.cjs"), exports);
+__exportStar(require("./cost/index.cjs"), exports);
+__exportStar(require("./model-function/index.cjs"), exports);
+__exportStar(require("./model-provider/index.cjs"), exports);
+__exportStar(require("./prompt/index.cjs"), exports);
+__exportStar(require("./run/index.cjs"), exports);
+__exportStar(require("./text-chunk/index.cjs"), exports);
+__exportStar(require("./util/index.cjs"), exports);
+__exportStar(require("./vector-index/index.cjs"), exports);

package/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./composed-function/index.js";
+export * from "./cost/index.js";
+export * from "./model-function/index.js";
+export * from "./model-provider/index.js";
+export * from "./prompt/index.js";
+export * from "./run/index.js";
+export * from "./text-chunk/index.js";
+export * from "./util/index.js";
+export * from "./vector-index/index.js";

package/index.js

@@ -0,0 +1,9 @@
+export * from "./composed-function/index.js";
+export * from "./cost/index.js";
+export * from "./model-function/index.js";
+export * from "./model-provider/index.js";
+export * from "./prompt/index.js";
+export * from "./run/index.js";
+export * from "./text-chunk/index.js";
+export * from "./util/index.js";
+export * from "./vector-index/index.js";

package/model-function/AbstractModel.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractModel = void 0;
+class AbstractModel {
+    constructor({ settings }) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+    }
+    // implemented as a separate accessor to remove all other properties from the model
+    get modelInformation() {
+        return {
+            provider: this.provider,
+            modelName: this.modelName,
+        };
+    }
+}
+exports.AbstractModel = AbstractModel;

package/model-function/AbstractModel.d.ts

@@ -0,0 +1,12 @@
+import { ModelInformation } from "./ModelInformation.js";
+import { Model, ModelSettings } from "./Model.js";
+export declare abstract class AbstractModel<SETTINGS extends ModelSettings> implements Model<SETTINGS> {
+    constructor({ settings }: {
+        settings: SETTINGS;
+    });
+    abstract readonly provider: string;
+    abstract readonly modelName: string | null;
+    get modelInformation(): ModelInformation;
+    readonly settings: SETTINGS;
+    abstract withSettings(additionalSettings: Partial<SETTINGS>): this;
+}

package/model-function/AbstractModel.js

@@ -0,0 +1,18 @@
+export class AbstractModel {
+    constructor({ settings }) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+    }
+    // implemented as a separate accessor to remove all other properties from the model
+    get modelInformation() {
+        return {
+            provider: this.provider,
+            modelName: this.modelName,
+        };
+    }
+}

package/model-function/FunctionOptions.cjs

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

package/model-function/FunctionOptions.d.ts

@@ -0,0 +1,6 @@
+import { Run } from "../run/Run.js";
+export interface FunctionOptions<SETTINGS> {
+    functionId?: string;
+    settings?: Partial<SETTINGS>;
+    run?: Run;
+}

package/model-function/FunctionOptions.js

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

package/model-function/Model.cjs

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

package/model-function/Model.d.ts

@@ -0,0 +1,23 @@
+import { ModelInformation } from "./ModelInformation.js";
+import { ModelCallObserver } from "./ModelCallObserver.js";
+export interface ModelSettings {
+    observers?: Array<ModelCallObserver>;
+}
+export interface Model<SETTINGS> {
+    modelInformation: ModelInformation;
+    readonly settings: SETTINGS;
+    /**
+     * The `withSettings` method creates a new model with the same configuration as the original model, but with the specified settings changed.
+     *
+     * @example
+     * const model = new OpenAITextGenerationModel({
+     *   model: "text-davinci-003",
+     *   maxTokens: 500,
+     * });
+     *
+     * const modelWithMoreTokens = model.withSettings({
+     *   maxTokens: 1000,
+     * });
+     */
+    withSettings(additionalSettings: Partial<SETTINGS>): this;
+}

package/model-function/Model.js

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

package/model-function/ModelCallEvent.cjs

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

package/model-function/ModelCallEvent.d.ts

@@ -0,0 +1,18 @@
+import { IdMetadata } from "../run/IdMetadata.js";
+import { ModelInformation } from "./ModelInformation.js";
+import { TextEmbeddingFinishedEvent, TextEmbeddingStartedEvent } from "./embed-text/TextEmbeddingEvent.js";
+import { ImageGenerationFinishedEvent, ImageGenerationStartedEvent } from "./generate-image/ImageGenerationEvent.js";
+import { JsonGenerationFinishedEvent, JsonGenerationStartedEvent } from "./generate-json/JsonGenerationEvent.js";
+import { TextGenerationFinishedEvent, TextGenerationStartedEvent } from "./generate-text/TextGenerationEvent.js";
+import { TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextStreamingEvent.js";
+import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./transcribe-audio/TranscriptionEvent.js";
+export type ModelCallEvent = ModelCallStartedEvent | ModelCallFinishedEvent;
+export type ModelCallStartedEventMetadata = IdMetadata & {
+    model: ModelInformation;
+    startEpochSeconds: number;
+};
+export type ModelCallStartedEvent = ImageGenerationStartedEvent | JsonGenerationStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
+export type ModelCallFinishedEventMetadata = ModelCallStartedEventMetadata & {
+    durationInMs: number;
+};
+export type ModelCallFinishedEvent = ImageGenerationFinishedEvent | JsonGenerationFinishedEvent | TextEmbeddingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;

package/model-function/ModelCallEvent.js

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