modelfusion 0.121.2 → 0.123.0

package/tool/execute-tool/executeTool.js

@@ -7,13 +7,13 @@ import { getRun } from "../../core/getRun.js";
 import { startDurationMeasurement } from "../../util/DurationMeasurement.js";
 import { runSafe } from "../../util/runSafe.js";
 import { ToolExecutionError } from "../ToolExecutionError.js";
-export async function executeTool(// eslint-disable-line @typescript-eslint/no-explicit-any
-tool, args, options) {
-    const fullResponse = await doExecuteTool(tool, args, options);
-    return options?.fullResponse ? fullResponse : fullResponse.output;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function executeTool({ tool, args, fullResponse, ...options }) {
+    const callResponse = await doExecuteTool({ tool, args, ...options });
+    return fullResponse ? callResponse : callResponse.output;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function doExecuteTool(tool, args, options) {
+async function doExecuteTool({ tool, args, ...options }) {
     const run = await getRun(options?.run);
     const eventSource = new FunctionEventSource({
         observers: [

package/tool/execute-tool/safeExecuteToolCall.cjs

@@ -11,7 +11,7 @@ async function safeExecuteToolCall(tool, toolCall, options) {
             toolCall,
             args: toolCall.args,
             ok: true,
-            result: await (0, executeTool_js_1.executeTool)(tool, toolCall.args, options),
+            result: await (0, executeTool_js_1.executeTool)({ tool, args: toolCall.args, ...options }),
         };
     }
     catch (error) {

package/tool/execute-tool/safeExecuteToolCall.js

@@ -8,7 +8,7 @@ export async function safeExecuteToolCall(tool, toolCall, options) {
             toolCall,
             args: toolCall.args,
             ok: true,
-            result: await executeTool(tool, toolCall.args, options),
+            result: await executeTool({ tool, args: toolCall.args, ...options }),
         };
     }
     catch (error) {

package/tool/generate-tool-call/TextGenerationToolCallModel.cjs

@@ -30,9 +30,11 @@ class TextGenerationToolCallModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCall(tool, prompt, options) {
-        const { rawResponse, text, metadata } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, tool), {
-            ...options,
+        const { rawResponse, text, metadata } = await (0, generateText_js_1.generateText)({
+            model: this.model,
+            prompt: this.format.createPrompt(prompt, tool),
             fullResponse: true,
+            ...options,
         });
         try {
             return {

package/tool/generate-tool-call/TextGenerationToolCallModel.js

@@ -27,9 +27,11 @@ export class TextGenerationToolCallModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCall(tool, prompt, options) {
-        const { rawResponse, text, metadata } = await generateText(this.model, this.format.createPrompt(prompt, tool), {
-            ...options,
+        const { rawResponse, text, metadata } = await generateText({
+            model: this.model,
+            prompt: this.format.createPrompt(prompt, tool),
             fullResponse: true,
+            ...options,
         });
         try {
             return {

package/tool/generate-tool-call/generateToolCall.cjs

@@ -4,12 +4,12 @@ exports.generateToolCall = void 0;
 const executeStandardCall_js_1 = require("../../model-function/executeStandardCall.cjs");
 const ToolCallArgumentsValidationError_js_1 = require("../ToolCallArgumentsValidationError.cjs");
 const ToolCallGenerationError_js_1 = require("../ToolCallGenerationError.cjs");
-async function generateToolCall(model, tool, prompt, options) {
+async function generateToolCall({ model, tool, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
         : prompt;
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-tool-call",
         input: expandedPrompt,
         model,
@@ -54,12 +54,12 @@ async function generateToolCall(model, tool, prompt, options) {
             }
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            toolCall: fullResponse.value,
-            response: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            toolCall: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
 exports.generateToolCall = generateToolCall;

package/tool/generate-tool-call/generateToolCall.d.ts

@@ -3,13 +3,19 @@ import { ModelCallMetadata } from "../../model-function/ModelCallMetadata.js";
 import { ToolCall } from "../ToolCall.js";
 import { ToolDefinition } from "../ToolDefinition.js";
 import { ToolCallGenerationModel, ToolCallGenerationModelSettings } from "./ToolCallGenerationModel.js";
-export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(model: ToolCallGenerationModel<PROMPT, SETTINGS>, tool: ToolDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT), options?: FunctionOptions & {
+export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(params: {
+    model: ToolCallGenerationModel<PROMPT, SETTINGS>;
+    tool: ToolDefinition<NAME, PARAMETERS>;
+    prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT);
     fullResponse?: false;
-}): Promise<ToolCall<NAME, PARAMETERS>>;
-export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(model: ToolCallGenerationModel<PROMPT, SETTINGS>, tool: ToolDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT), options: FunctionOptions & {
+} & FunctionOptions): Promise<ToolCall<NAME, PARAMETERS>>;
+export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(params: {
+    model: ToolCallGenerationModel<PROMPT, SETTINGS>;
+    tool: ToolDefinition<NAME, PARAMETERS>;
+    prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT);
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     toolCall: ToolCall<NAME, PARAMETERS>;
-    response: unknown;
+    rawResponse: unknown;
     metadata: ModelCallMetadata;
 }>;

package/tool/generate-tool-call/generateToolCall.js

@@ -1,12 +1,12 @@
 import { executeStandardCall } from "../../model-function/executeStandardCall.js";
 import { ToolCallArgumentsValidationError } from "../ToolCallArgumentsValidationError.js";
 import { ToolCallGenerationError } from "../ToolCallGenerationError.js";
-export async function generateToolCall(model, tool, prompt, options) {
+export async function generateToolCall({ model, tool, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
         : prompt;
-    const fullResponse = await executeStandardCall({
+    const callResponse = await executeStandardCall({
         functionType: "generate-tool-call",
         input: expandedPrompt,
         model,
@@ -51,11 +51,11 @@ export async function generateToolCall(model, tool, prompt, options) {
             }
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            toolCall: fullResponse.value,
-            response: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            toolCall: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }

package/tool/generate-tool-calls/TextGenerationToolCallsModel.cjs

@@ -30,9 +30,11 @@ class TextGenerationToolCallsModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCalls(tools, prompt, options) {
-        const { rawResponse, text: generatedText, metadata, } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, tools), {
-            ...options,
+        const { rawResponse, text: generatedText, metadata, } = await (0, generateText_js_1.generateText)({
+            model: this.model,
+            prompt: this.template.createPrompt(prompt, tools),
             fullResponse: true,
+            ...options,
         });
         try {
             const { text, toolCalls } = this.template.extractToolCallsAndText(generatedText);

package/tool/generate-tool-calls/TextGenerationToolCallsModel.js

@@ -27,9 +27,11 @@ export class TextGenerationToolCallsModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCalls(tools, prompt, options) {
-        const { rawResponse, text: generatedText, metadata, } = await generateText(this.model, this.template.createPrompt(prompt, tools), {
-            ...options,
+        const { rawResponse, text: generatedText, metadata, } = await generateText({
+            model: this.model,
+            prompt: this.template.createPrompt(prompt, tools),
             fullResponse: true,
+            ...options,
         });
         try {
             const { text, toolCalls } = this.template.extractToolCallsAndText(generatedText);

package/tool/generate-tool-calls/generateToolCalls.cjs

@@ -4,12 +4,12 @@ exports.generateToolCalls = void 0;
 const executeStandardCall_js_1 = require("../../model-function/executeStandardCall.cjs");
 const NoSuchToolDefinitionError_js_1 = require("../NoSuchToolDefinitionError.cjs");
 const ToolCallArgumentsValidationError_js_1 = require("../ToolCallArgumentsValidationError.cjs");
-async function generateToolCalls(model, tools, prompt, options) {
+async function generateToolCalls({ model, tools, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
         : prompt;
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-tool-calls",
         input: expandedPrompt,
         model,
@@ -58,6 +58,6 @@ async function generateToolCalls(model, tools, prompt, options) {
             };
         },
     });
-    return options?.fullResponse ? fullResponse : fullResponse.value;
+    return fullResponse ? callResponse : callResponse.value;
 }
 exports.generateToolCalls = generateToolCalls;

package/tool/generate-tool-calls/generateToolCalls.d.ts

@@ -14,15 +14,21 @@ type ToToolCallUnion<T> = {
     } : never;
 }[keyof T];
 type ToOutputValue<TOOL_CALLS extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = ToToolCallUnion<ToToolCallDefinitionMap<TOOL_CALLS>>;
-export declare function generateToolCalls<TOOLS extends Array<ToolDefinition<any, any>>, PROMPT>(model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions & {
+export declare function generateToolCalls<TOOLS extends Array<ToolDefinition<any, any>>, PROMPT>(params: {
+    model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>;
+    tools: TOOLS;
+    prompt: PROMPT | ((tools: TOOLS) => PROMPT);
     fullResponse?: false;
-}): Promise<{
+} & FunctionOptions): Promise<{
     text: string | null;
     toolCalls: Array<ToOutputValue<TOOLS>> | null;
 }>;
-export declare function generateToolCalls<TOOLS extends ToolDefinition<any, any>[], PROMPT>(model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options: FunctionOptions & {
-    fullResponse?: boolean;
-}): Promise<{
+export declare function generateToolCalls<TOOLS extends ToolDefinition<any, any>[], PROMPT>(params: {
+    model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>;
+    tools: TOOLS;
+    prompt: PROMPT | ((tools: TOOLS) => PROMPT);
+    fullResponse: true;
+} & FunctionOptions): Promise<{
     value: {
         text: string | null;
         toolCalls: Array<ToOutputValue<TOOLS>>;

package/tool/generate-tool-calls/generateToolCalls.js

@@ -1,12 +1,12 @@
 import { executeStandardCall } from "../../model-function/executeStandardCall.js";
 import { NoSuchToolDefinitionError } from "../NoSuchToolDefinitionError.js";
 import { ToolCallArgumentsValidationError } from "../ToolCallArgumentsValidationError.js";
-export async function generateToolCalls(model, tools, prompt, options) {
+export async function generateToolCalls({ model, tools, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
         : prompt;
-    const fullResponse = await executeStandardCall({
+    const callResponse = await executeStandardCall({
         functionType: "generate-tool-calls",
         input: expandedPrompt,
         model,
@@ -55,5 +55,5 @@ export async function generateToolCalls(model, tools, prompt, options) {
             };
         },
     });
-    return options?.fullResponse ? fullResponse : fullResponse.value;
+    return fullResponse ? callResponse : callResponse.value;
 }

package/tool/use-tool/useTool.cjs

@@ -15,7 +15,7 @@ const generateToolCall_js_1 = require("../generate-tool-call/generateToolCall.cj
  * @see {@link generateToolCall}
  * @see {@link executeTool}
  */
-async function useTool(model, tool, prompt, options) {
+async function useTool({ model, tool, prompt, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
@@ -24,7 +24,7 @@ async function useTool(model, tool, prompt, options) {
         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),
+        execute: async (options) => (0, safeExecuteToolCall_js_1.safeExecuteToolCall)(tool, await (0, generateToolCall_js_1.generateToolCall)({ model, tool, prompt: expandedPrompt, ...options }), options),
     });
 }
 exports.useTool = useTool;

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

@@ -13,4 +13,8 @@ import { ToolCallGenerationModel, ToolCallGenerationModelSettings } from "../gen
  * @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"]>>>>;
+export declare function useTool<PROMPT, TOOL extends Tool<string, any, any>>({ model, tool, prompt, ...options }: {
+    model: ToolCallGenerationModel<PROMPT, ToolCallGenerationModelSettings>;
+    tool: TOOL;
+    prompt: PROMPT | ((tool: TOOL) => PROMPT);
+} & FunctionOptions): Promise<ToolCallResult<TOOL["name"], TOOL["parameters"], Awaited<ReturnType<TOOL["execute"]>>>>;

package/tool/use-tool/useTool.js

@@ -12,7 +12,7 @@ import { generateToolCall } from "../generate-tool-call/generateToolCall.js";
  * @see {@link generateToolCall}
  * @see {@link executeTool}
  */
-export async function useTool(model, tool, prompt, options) {
+export async function useTool({ model, tool, prompt, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
@@ -21,6 +21,6 @@ export async function useTool(model, tool, prompt, options) {
         options,
         input: expandedPrompt,
         functionType: "use-tool",
-        execute: async (options) => safeExecuteToolCall(tool, await generateToolCall(model, tool, expandedPrompt, options), options),
+        execute: async (options) => safeExecuteToolCall(tool, await generateToolCall({ model, tool, prompt: expandedPrompt, ...options }), options),
     });
 }

package/tool/use-tools/useTools.cjs

@@ -5,7 +5,7 @@ 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 generateToolCalls_js_1 = require("../generate-tool-calls/generateToolCalls.cjs");
-async function useTools(model, tools, prompt, options) {
+async function useTools({ model, tools, prompt, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
@@ -15,7 +15,13 @@ async function useTools(model, tools, prompt, options) {
         input: expandedPrompt,
         functionType: "use-tools",
         execute: async (options) => {
-            const modelResponse = await (0, generateToolCalls_js_1.generateToolCalls)(model, tools, expandedPrompt, { ...options, fullResponse: false });
+            const modelResponse = await (0, generateToolCalls_js_1.generateToolCalls)({
+                model,
+                tools,
+                prompt: expandedPrompt,
+                fullResponse: false,
+                ...options,
+            });
             const { toolCalls, text } = modelResponse;
             // no tool calls:
             if (toolCalls == null) {

package/tool/use-tools/useTools.d.ts

@@ -11,7 +11,11 @@ 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 useTools<PROMPT, TOOLS extends Array<Tool<any, any, any>>>(model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions): Promise<{
+export declare function useTools<PROMPT, TOOLS extends Array<Tool<any, any, any>>>({ model, tools, prompt, ...options }: {
+    model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>;
+    tools: TOOLS;
+    prompt: PROMPT | ((tools: TOOLS) => PROMPT);
+} & FunctionOptions): Promise<{
     text: string | null;
     toolResults: Array<ToOutputValue<TOOLS>> | null;
 }>;

package/tool/use-tools/useTools.js

@@ -2,7 +2,7 @@ import { executeFunctionCall } from "../../core/executeFunctionCall.js";
 import { ToolCallError } from "../ToolCallError.js";
 import { safeExecuteToolCall } from "../execute-tool/safeExecuteToolCall.js";
 import { generateToolCalls } from "../generate-tool-calls/generateToolCalls.js";
-export async function useTools(model, tools, prompt, options) {
+export async function useTools({ model, tools, prompt, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
@@ -12,7 +12,13 @@ export async function useTools(model, tools, prompt, options) {
         input: expandedPrompt,
         functionType: "use-tools",
         execute: async (options) => {
-            const modelResponse = await generateToolCalls(model, tools, expandedPrompt, { ...options, fullResponse: false });
+            const modelResponse = await generateToolCalls({
+                model,
+                tools,
+                prompt: expandedPrompt,
+                fullResponse: false,
+                ...options,
+            });
             const { toolCalls, text } = modelResponse;
             // no tool calls:
             if (toolCalls == null) {

package/vector-index/VectorIndexRetriever.cjs

@@ -31,7 +31,11 @@ class VectorIndexRetriever {
         };
     }
     async retrieve(query, options) {
-        const embedding = await (0, embed_js_1.embed)(this.embeddingModel, query, options);
+        const embedding = await (0, embed_js_1.embed)({
+            model: this.embeddingModel,
+            value: query,
+            ...options,
+        });
         const queryResult = await this.vectorIndex.queryByVector({
             queryVector: embedding,
             maxResults: this.settings.maxResults ?? 1,

package/vector-index/VectorIndexRetriever.js

@@ -28,7 +28,11 @@ export class VectorIndexRetriever {
         };
     }
     async retrieve(query, options) {
-        const embedding = await embed(this.embeddingModel, query, options);
+        const embedding = await embed({
+            model: this.embeddingModel,
+            value: query,
+            ...options,
+        });
         const queryResult = await this.vectorIndex.queryByVector({
             queryVector: embedding,
             maxResults: this.settings.maxResults ?? 1,

package/vector-index/upsertIntoVectorIndex.cjs

@@ -12,7 +12,11 @@ async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, generateId =
         inputPropertyName: "objects",
         execute: async (options) => {
             // many embedding models support bulk embedding, so we first embed all texts:
-            const embeddings = await (0, embed_js_1.embedMany)(embeddingModel, objects.map(getValueToEmbed), options);
+            const embeddings = await (0, embed_js_1.embedMany)({
+                model: embeddingModel,
+                values: objects.map(getValueToEmbed),
+                ...options,
+            });
             await vectorIndex.upsertMany(objects.map((object, i) => ({
                 id: getId?.(object, i) ?? generateId(),
                 vector: embeddings[i],

package/vector-index/upsertIntoVectorIndex.js

@@ -9,7 +9,11 @@ export async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, gener
         inputPropertyName: "objects",
         execute: async (options) => {
             // many embedding models support bulk embedding, so we first embed all texts:
-            const embeddings = await embedMany(embeddingModel, objects.map(getValueToEmbed), options);
+            const embeddings = await embedMany({
+                model: embeddingModel,
+                values: objects.map(getValueToEmbed),
+                ...options,
+            });
             await vectorIndex.upsertMany(objects.map((object, i) => ({
                 id: getId?.(object, i) ?? generateId(),
                 vector: embeddings[i],

package/classifier/SemanticClassifier.cjs

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SemanticClassifier = void 0;
-const embed_js_1 = require("../model-function/embed/embed.cjs");
-const cosineSimilarity_js_1 = require("../util/cosineSimilarity.cjs");
-class SemanticClassifier {
-    constructor({ clusters, embeddingModel, similarityThreshold, }) {
-        Object.defineProperty(this, "clusters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "embeddingModel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "similarityThreshold", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "embeddings", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.clusters = clusters;
-        this.embeddingModel = embeddingModel;
-        this.similarityThreshold = similarityThreshold;
-    }
-    async getEmbeddings() {
-        if (this.embeddings != null) {
-            return this.embeddings;
-        }
-        const embeddings = [];
-        for (const cluster of this.clusters) {
-            const clusterEmbeddings = await (0, embed_js_1.embedMany)(this.embeddingModel, cluster.values);
-            for (let i = 0; i < clusterEmbeddings.length; i++) {
-                embeddings.push({
-                    embedding: clusterEmbeddings[i],
-                    clusterValue: cluster.values[i],
-                    clusterName: cluster.name,
-                });
-            }
-        }
-        this.embeddings = embeddings; // lazy caching
-        return embeddings;
-    }
-    async classify(value) {
-        const valueEmbedding = await (0, embed_js_1.embed)(this.embeddingModel, value);
-        const clusterEmbeddings = await this.getEmbeddings();
-        const allMatches = [];
-        for (const embedding of clusterEmbeddings) {
-            const similarity = (0, cosineSimilarity_js_1.cosineSimilarity)(valueEmbedding, embedding.embedding);
-            if (similarity >= this.similarityThreshold) {
-                allMatches.push({
-                    similarity,
-                    clusterValue: embedding.clusterValue,
-                    clusterName: embedding.clusterName,
-                });
-            }
-        }
-        // sort (highest similarity first)
-        allMatches.sort((a, b) => b.similarity - a.similarity);
-        return allMatches.length > 0
-            ? allMatches[0].clusterName
-            : null;
-    }
-}
-exports.SemanticClassifier = SemanticClassifier;

package/classifier/SemanticClassifier.d.ts

@@ -1,25 +0,0 @@
-import { Vector } from "../core/Vector.js";
-import { EmbeddingModel } from "../model-function/embed/EmbeddingModel.js";
-export interface SemanticCluster<VALUE, NAME extends string> {
-    name: NAME;
-    values: VALUE[];
-}
-export declare class SemanticClassifier<VALUE, CLUSTERS extends Array<SemanticCluster<VALUE, string>>> {
-    readonly clusters: CLUSTERS;
-    readonly embeddingModel: EmbeddingModel<VALUE>;
-    readonly similarityThreshold: number;
-    private embeddings;
-    constructor({ clusters, embeddingModel, similarityThreshold, }: {
-        clusters: CLUSTERS;
-        embeddingModel: EmbeddingModel<VALUE>;
-        similarityThreshold: number;
-    });
-    getEmbeddings(): Promise<{
-        embedding: Vector;
-        clusterValue: VALUE;
-        clusterName: string;
-    }[]>;
-    classify(value: VALUE): Promise<ClusterNames<CLUSTERS> | null>;
-}
-type ClusterNames<CLUSTERS> = CLUSTERS extends Array<SemanticCluster<unknown, infer NAME>> ? NAME : never;
-export {};

package/classifier/SemanticClassifier.js

@@ -1,71 +0,0 @@
-import { embed, embedMany } from "../model-function/embed/embed.js";
-import { cosineSimilarity } from "../util/cosineSimilarity.js";
-export class SemanticClassifier {
-    constructor({ clusters, embeddingModel, similarityThreshold, }) {
-        Object.defineProperty(this, "clusters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "embeddingModel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "similarityThreshold", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "embeddings", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.clusters = clusters;
-        this.embeddingModel = embeddingModel;
-        this.similarityThreshold = similarityThreshold;
-    }
-    async getEmbeddings() {
-        if (this.embeddings != null) {
-            return this.embeddings;
-        }
-        const embeddings = [];
-        for (const cluster of this.clusters) {
-            const clusterEmbeddings = await embedMany(this.embeddingModel, cluster.values);
-            for (let i = 0; i < clusterEmbeddings.length; i++) {
-                embeddings.push({
-                    embedding: clusterEmbeddings[i],
-                    clusterValue: cluster.values[i],
-                    clusterName: cluster.name,
-                });
-            }
-        }
-        this.embeddings = embeddings; // lazy caching
-        return embeddings;
-    }
-    async classify(value) {
-        const valueEmbedding = await embed(this.embeddingModel, value);
-        const clusterEmbeddings = await this.getEmbeddings();
-        const allMatches = [];
-        for (const embedding of clusterEmbeddings) {
-            const similarity = cosineSimilarity(valueEmbedding, embedding.embedding);
-            if (similarity >= this.similarityThreshold) {
-                allMatches.push({
-                    similarity,
-                    clusterValue: embedding.clusterValue,
-                    clusterName: embedding.clusterName,
-                });
-            }
-        }
-        // sort (highest similarity first)
-        allMatches.sort((a, b) => b.similarity - a.similarity);
-        return allMatches.length > 0
-            ? allMatches[0].clusterName
-            : null;
-    }
-}

package/classifier/index.d.ts

@@ -1 +0,0 @@
-export * from "./SemanticClassifier.js";

package/classifier/index.js

@@ -1 +0,0 @@
-export * from "./SemanticClassifier.js";