modelfusion 0.110.0 → 0.112.0

package/model-provider/huggingface/index.cjs

@@ -26,10 +26,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.huggingface = exports.HuggingFaceError = void 0;
+exports.huggingface = void 0;
 __exportStar(require("./HuggingFaceApiConfiguration.cjs"), exports);
-var HuggingFaceError_js_1 = require("./HuggingFaceError.cjs");
-Object.defineProperty(exports, "HuggingFaceError", { enumerable: true, get: function () { return HuggingFaceError_js_1.HuggingFaceError; } });
 exports.huggingface = __importStar(require("./HuggingFaceFacade.cjs"));
 __exportStar(require("./HuggingFaceTextEmbeddingModel.cjs"), exports);
 __exportStar(require("./HuggingFaceTextGenerationModel.cjs"), exports);

package/model-provider/huggingface/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./HuggingFaceApiConfiguration.js";
-export { HuggingFaceError, HuggingFaceErrorData } from "./HuggingFaceError.js";
+export { HuggingFaceErrorData } from "./HuggingFaceError.js";
 export * as huggingface from "./HuggingFaceFacade.js";
 export * from "./HuggingFaceTextEmbeddingModel.js";
 export * from "./HuggingFaceTextGenerationModel.js";

package/model-provider/huggingface/index.js

@@ -1,5 +1,4 @@
 export * from "./HuggingFaceApiConfiguration.js";
-export { HuggingFaceError } from "./HuggingFaceError.js";
 export * as huggingface from "./HuggingFaceFacade.js";
 export * from "./HuggingFaceTextEmbeddingModel.js";
 export * from "./HuggingFaceTextGenerationModel.js";

package/model-provider/llamacpp/LlamaCppApiConfiguration.cjs

@@ -2,13 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlamaCppApiConfiguration = void 0;
 const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
-class LlamaCppApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
-    constructor({ baseUrl = "http://127.0.0.1:8080", retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the Llama.cpp server.
+ * It calls the API at http://127.0.0.1:8080 by default.
+ */
+class LlamaCppApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfigurationWithDefaults {
+    constructor(settings = {}) {
         super({
-            baseUrl,
-            headers: {},
-            retry,
-            throttle,
+            ...settings,
+            baseUrlDefaults: {
+                protocol: "http",
+                host: "127.0.0.1",
+                port: "8080",
+                path: "",
+            },
         });
     }
 }

package/model-provider/llamacpp/LlamaCppApiConfiguration.d.ts

@@ -1,10 +1,8 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
-import { RetryFunction } from "../../core/api/RetryFunction.js";
-import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
-export declare class LlamaCppApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl, retry, throttle, }?: {
-        baseUrl?: string;
-        retry?: RetryFunction;
-        throttle?: ThrottleFunction;
-    });
+import { BaseUrlApiConfigurationWithDefaults, PartialBaseUrlPartsApiConfigurationOptions } from "../../core/api/BaseUrlApiConfiguration.js";
+/**
+ * Creates an API configuration for the Llama.cpp server.
+ * It calls the API at http://127.0.0.1:8080 by default.
+ */
+export declare class LlamaCppApiConfiguration extends BaseUrlApiConfigurationWithDefaults {
+    constructor(settings?: PartialBaseUrlPartsApiConfigurationOptions);
 }

package/model-provider/llamacpp/LlamaCppApiConfiguration.js

@@ -1,11 +1,18 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
-export class LlamaCppApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl = "http://127.0.0.1:8080", retry, throttle, } = {}) {
+import { BaseUrlApiConfigurationWithDefaults, } from "../../core/api/BaseUrlApiConfiguration.js";
+/**
+ * Creates an API configuration for the Llama.cpp server.
+ * It calls the API at http://127.0.0.1:8080 by default.
+ */
+export class LlamaCppApiConfiguration extends BaseUrlApiConfigurationWithDefaults {
+    constructor(settings = {}) {
         super({
-            baseUrl,
-            headers: {},
-            retry,
-            throttle,
+            ...settings,
+            baseUrlDefaults: {
+                protocol: "http",
+                host: "127.0.0.1",
+                port: "8080",
+                path: "",
+            },
         });
     }
 }

package/model-provider/llamacpp/LlamaCppCompletionModel.cjs

@@ -245,13 +245,13 @@ const llamaCppTextGenerationResponseSchema = zod_1.z.object({
     tokens_predicted: zod_1.z.number(),
     truncated: zod_1.z.boolean(),
 });
-const llamaCppTextStreamChunkSchema = (0, ZodSchema_js_1.zodSchema)(zod_1.z.discriminatedUnion("stop", [
+const llamaCppTextStreamChunkSchema = zod_1.z.discriminatedUnion("stop", [
     zod_1.z.object({
         content: zod_1.z.string(),
         stop: zod_1.z.literal(false),
     }),
     llamaCppTextGenerationResponseSchema,
-]));
+]);
 async function createLlamaCppFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     // process the stream asynchonously (no 'await' on purpose):
@@ -262,7 +262,7 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                 const data = event.data;
                 const eventData = (0, parseJSON_js_1.parseJSON)({
                     text: data,
-                    schema: llamaCppTextStreamChunkSchema,
+                    schema: (0, ZodSchema_js_1.zodSchema)(llamaCppTextStreamChunkSchema),
                 });
                 queue.push({ type: "delta", deltaValue: eventData });
                 if (eventData.stop) {
@@ -287,7 +287,7 @@ exports.LlamaCppCompletionResponseFormat = {
      */
     json: {
         stream: false,
-        handler: (0, postToApi_js_1.createJsonResponseHandler)(llamaCppTextGenerationResponseSchema),
+        handler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(llamaCppTextGenerationResponseSchema)),
     },
     /**
      * Returns an async iterable over the full deltas (all choices, including full current state at time of event)

package/model-provider/llamacpp/LlamaCppCompletionModel.d.ts

@@ -479,7 +479,130 @@ declare const llamaCppTextGenerationResponseSchema: z.ZodObject<{
     truncated: boolean;
 }>;
 export type LlamaCppTextGenerationResponse = z.infer<typeof llamaCppTextGenerationResponseSchema>;
-declare const llamaCppTextStreamChunkSchema: import("../../core/schema/ZodSchema.js").ZodSchema<{
+declare const llamaCppTextStreamChunkSchema: z.ZodDiscriminatedUnion<"stop", [z.ZodObject<{
+    content: z.ZodString;
+    stop: z.ZodLiteral<false>;
+}, "strip", z.ZodTypeAny, {
+    stop: false;
+    content: string;
+}, {
+    stop: false;
+    content: string;
+}>, z.ZodObject<{
+    content: z.ZodString;
+    stop: z.ZodLiteral<true>;
+    generation_settings: z.ZodObject<{
+        frequency_penalty: z.ZodNumber;
+        ignore_eos: z.ZodBoolean;
+        logit_bias: z.ZodArray<z.ZodNumber, "many">;
+        mirostat: z.ZodNumber;
+        mirostat_eta: z.ZodNumber;
+        mirostat_tau: z.ZodNumber;
+        model: z.ZodString;
+        n_ctx: z.ZodNumber;
+        n_keep: z.ZodNumber;
+        n_predict: z.ZodNumber;
+        n_probs: z.ZodNumber;
+        penalize_nl: z.ZodBoolean;
+        presence_penalty: z.ZodNumber;
+        repeat_last_n: z.ZodNumber;
+        repeat_penalty: z.ZodNumber;
+        seed: z.ZodNumber;
+        stop: z.ZodArray<z.ZodString, "many">;
+        stream: z.ZodBoolean;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        tfs_z: z.ZodNumber;
+        top_k: z.ZodNumber;
+        top_p: z.ZodNumber;
+        typical_p: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        stream: boolean;
+        stop: string[];
+        seed: number;
+        mirostat: number;
+        frequency_penalty: number;
+        ignore_eos: boolean;
+        logit_bias: number[];
+        mirostat_eta: number;
+        mirostat_tau: number;
+        n_ctx: number;
+        n_keep: number;
+        n_predict: number;
+        n_probs: number;
+        penalize_nl: boolean;
+        presence_penalty: number;
+        repeat_last_n: number;
+        repeat_penalty: number;
+        tfs_z: number;
+        top_k: number;
+        top_p: number;
+        typical_p: number;
+        temperature?: number | undefined;
+    }, {
+        model: string;
+        stream: boolean;
+        stop: string[];
+        seed: number;
+        mirostat: number;
+        frequency_penalty: number;
+        ignore_eos: boolean;
+        logit_bias: number[];
+        mirostat_eta: number;
+        mirostat_tau: number;
+        n_ctx: number;
+        n_keep: number;
+        n_predict: number;
+        n_probs: number;
+        penalize_nl: boolean;
+        presence_penalty: number;
+        repeat_last_n: number;
+        repeat_penalty: number;
+        tfs_z: number;
+        top_k: number;
+        top_p: number;
+        typical_p: number;
+        temperature?: number | undefined;
+    }>;
+    model: z.ZodString;
+    prompt: z.ZodString;
+    stopped_eos: z.ZodBoolean;
+    stopped_limit: z.ZodBoolean;
+    stopped_word: z.ZodBoolean;
+    stopping_word: z.ZodString;
+    timings: z.ZodObject<{
+        predicted_ms: z.ZodNumber;
+        predicted_n: z.ZodNumber;
+        predicted_per_second: z.ZodNullable<z.ZodNumber>;
+        predicted_per_token_ms: z.ZodNullable<z.ZodNumber>;
+        prompt_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        prompt_n: z.ZodNumber;
+        prompt_per_second: z.ZodNullable<z.ZodNumber>;
+        prompt_per_token_ms: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        predicted_ms: number;
+        predicted_n: number;
+        predicted_per_second: number | null;
+        predicted_per_token_ms: number | null;
+        prompt_n: number;
+        prompt_per_second: number | null;
+        prompt_per_token_ms: number | null;
+        prompt_ms?: number | null | undefined;
+    }, {
+        predicted_ms: number;
+        predicted_n: number;
+        predicted_per_second: number | null;
+        predicted_per_token_ms: number | null;
+        prompt_n: number;
+        prompt_per_second: number | null;
+        prompt_per_token_ms: number | null;
+        prompt_ms?: number | null | undefined;
+    }>;
+    tokens_cached: z.ZodNumber;
+    tokens_evaluated: z.ZodNumber;
+    tokens_predicted: z.ZodNumber;
+    truncated: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
     model: string;
     stop: true;
     content: string;
@@ -527,11 +650,56 @@ declare const llamaCppTextStreamChunkSchema: import("../../core/schema/ZodSchema
     tokens_evaluated: number;
     tokens_predicted: number;
     truncated: boolean;
-} | {
-    stop: false;
+}, {
+    model: string;
+    stop: true;
     content: string;
-}>;
-export type LlamaCppTextStreamChunk = (typeof llamaCppTextStreamChunkSchema)["_type"];
+    prompt: string;
+    generation_settings: {
+        model: string;
+        stream: boolean;
+        stop: string[];
+        seed: number;
+        mirostat: number;
+        frequency_penalty: number;
+        ignore_eos: boolean;
+        logit_bias: number[];
+        mirostat_eta: number;
+        mirostat_tau: number;
+        n_ctx: number;
+        n_keep: number;
+        n_predict: number;
+        n_probs: number;
+        penalize_nl: boolean;
+        presence_penalty: number;
+        repeat_last_n: number;
+        repeat_penalty: number;
+        tfs_z: number;
+        top_k: number;
+        top_p: number;
+        typical_p: number;
+        temperature?: number | undefined;
+    };
+    stopped_eos: boolean;
+    stopped_limit: boolean;
+    stopped_word: boolean;
+    stopping_word: string;
+    timings: {
+        predicted_ms: number;
+        predicted_n: number;
+        predicted_per_second: number | null;
+        predicted_per_token_ms: number | null;
+        prompt_n: number;
+        prompt_per_second: number | null;
+        prompt_per_token_ms: number | null;
+        prompt_ms?: number | null | undefined;
+    };
+    tokens_cached: number;
+    tokens_evaluated: number;
+    tokens_predicted: number;
+    truncated: boolean;
+}>]>;
+export type LlamaCppTextStreamChunk = z.infer<typeof llamaCppTextStreamChunkSchema>;
 export type LlamaCppCompletionResponseFormatType<T> = {
     stream: boolean;
     handler: ResponseHandler<T>;

package/model-provider/llamacpp/LlamaCppCompletionModel.js

@@ -241,13 +241,13 @@ const llamaCppTextGenerationResponseSchema = z.object({
     tokens_predicted: z.number(),
     truncated: z.boolean(),
 });
-const llamaCppTextStreamChunkSchema = zodSchema(z.discriminatedUnion("stop", [
+const llamaCppTextStreamChunkSchema = z.discriminatedUnion("stop", [
     z.object({
         content: z.string(),
         stop: z.literal(false),
     }),
     llamaCppTextGenerationResponseSchema,
-]));
+]);
 async function createLlamaCppFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue();
     // process the stream asynchonously (no 'await' on purpose):
@@ -258,7 +258,7 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                 const data = event.data;
                 const eventData = parseJSON({
                     text: data,
-                    schema: llamaCppTextStreamChunkSchema,
+                    schema: zodSchema(llamaCppTextStreamChunkSchema),
                 });
                 queue.push({ type: "delta", deltaValue: eventData });
                 if (eventData.stop) {
@@ -283,7 +283,7 @@ export const LlamaCppCompletionResponseFormat = {
      */
     json: {
         stream: false,
-        handler: createJsonResponseHandler(llamaCppTextGenerationResponseSchema),
+        handler: createJsonResponseHandler(zodSchema(llamaCppTextGenerationResponseSchema)),
     },
     /**
      * Returns an async iterable over the full deltas (all choices, including full current state at time of event)

package/model-provider/llamacpp/LlamaCppError.cjs

@@ -1,33 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.failedLlamaCppCallResponseHandler = exports.LlamaCppError = exports.llamaCppErrorDataSchema = void 0;
+exports.failedLlamaCppCallResponseHandler = void 0;
 const zod_1 = require("zod");
-const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
-const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
-exports.llamaCppErrorDataSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
+const llamaCppErrorDataSchema = zod_1.z.object({
     error: zod_1.z.string(),
-}));
-class LlamaCppError extends ApiCallError_js_1.ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message = data.error, }) {
-        super({ message, statusCode, requestBodyValues, url });
-        Object.defineProperty(this, "data", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.data = data;
-    }
-}
-exports.LlamaCppError = LlamaCppError;
-const failedLlamaCppCallResponseHandler = async ({ response, url, requestBodyValues }) => new LlamaCppError({
-    url,
-    requestBodyValues,
-    statusCode: response.status,
-    data: (0, parseJSON_js_1.parseJSON)({
-        text: await response.text(),
-        schema: exports.llamaCppErrorDataSchema,
-    }),
 });
-exports.failedLlamaCppCallResponseHandler = failedLlamaCppCallResponseHandler;
+exports.failedLlamaCppCallResponseHandler = (0, postToApi_js_1.createJsonErrorResponseHandler)({
+    errorSchema: (0, ZodSchema_js_1.zodSchema)(llamaCppErrorDataSchema),
+    errorToMessage: (error) => error.error,
+});

package/model-provider/llamacpp/LlamaCppError.d.ts

@@ -1,18 +1,11 @@
-import { ApiCallError } from "../../core/api/ApiCallError.js";
-import { ResponseHandler } from "../../core/api/postToApi.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
-export declare const llamaCppErrorDataSchema: ZodSchema<{
+import { z } from "zod";
+declare const llamaCppErrorDataSchema: z.ZodObject<{
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+}, {
     error: string;
 }>;
-export type LlamaCppErrorData = (typeof llamaCppErrorDataSchema)["_type"];
-export declare class LlamaCppError extends ApiCallError {
-    readonly data: LlamaCppErrorData;
-    constructor({ data, statusCode, url, requestBodyValues, message, }: {
-        message?: string;
-        statusCode: number;
-        url: string;
-        requestBodyValues: unknown;
-        data: LlamaCppErrorData;
-    });
-}
-export declare const failedLlamaCppCallResponseHandler: ResponseHandler<ApiCallError>;
+export type LlamaCppErrorData = z.infer<typeof llamaCppErrorDataSchema>;
+export declare const failedLlamaCppCallResponseHandler: import("../../core/api/postToApi.js").ResponseHandler<import("../../index.js").ApiCallError>;
+export {};

package/model-provider/llamacpp/LlamaCppError.js

@@ -1,28 +1,10 @@
 import { z } from "zod";
-import { ApiCallError } from "../../core/api/ApiCallError.js";
-import { parseJSON } from "../../core/schema/parseJSON.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
-export const llamaCppErrorDataSchema = new ZodSchema(z.object({
+import { createJsonErrorResponseHandler } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+const llamaCppErrorDataSchema = z.object({
     error: z.string(),
-}));
-export class LlamaCppError extends ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message = data.error, }) {
-        super({ message, statusCode, requestBodyValues, url });
-        Object.defineProperty(this, "data", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.data = data;
-    }
-}
-export const failedLlamaCppCallResponseHandler = async ({ response, url, requestBodyValues }) => new LlamaCppError({
-    url,
-    requestBodyValues,
-    statusCode: response.status,
-    data: parseJSON({
-        text: await response.text(),
-        schema: llamaCppErrorDataSchema,
-    }),
+});
+export const failedLlamaCppCallResponseHandler = createJsonErrorResponseHandler({
+    errorSchema: zodSchema(llamaCppErrorDataSchema),
+    errorToMessage: (error) => error.error,
 });

package/model-provider/llamacpp/LlamaCppFacade.cjs

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tokenizer = exports.TextEmbedder = exports.TextGenerator = void 0;
+exports.Tokenizer = exports.TextEmbedder = exports.TextGenerator = exports.Api = void 0;
 const LlamaCppApiConfiguration_js_1 = require("./LlamaCppApiConfiguration.cjs");
-const LlamaCppTextEmbeddingModel_js_1 = require("./LlamaCppTextEmbeddingModel.cjs");
 const LlamaCppCompletionModel_js_1 = require("./LlamaCppCompletionModel.cjs");
+const LlamaCppTextEmbeddingModel_js_1 = require("./LlamaCppTextEmbeddingModel.cjs");
 const LlamaCppTokenizer_js_1 = require("./LlamaCppTokenizer.cjs");
+/**
+ * Creates an API configuration for the Llama.cpp server.
+ * It calls the API at http://127.0.0.1:8080 by default.
+ */
+function Api(settings) {
+    return new LlamaCppApiConfiguration_js_1.LlamaCppApiConfiguration(settings);
+}
+exports.Api = Api;
 function TextGenerator(settings = {}) {
     return new LlamaCppCompletionModel_js_1.LlamaCppCompletionModel(settings);
 }

package/model-provider/llamacpp/LlamaCppFacade.d.ts

@@ -1,7 +1,14 @@
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { LlamaCppTextEmbeddingModel, LlamaCppTextEmbeddingModelSettings } from "./LlamaCppTextEmbeddingModel.js";
+import { PartialBaseUrlPartsApiConfigurationOptions } from "../../core/api/BaseUrlApiConfiguration.js";
+import { LlamaCppApiConfiguration } from "./LlamaCppApiConfiguration.js";
 import { LlamaCppCompletionModel, LlamaCppCompletionModelSettings } from "./LlamaCppCompletionModel.js";
+import { LlamaCppTextEmbeddingModel, LlamaCppTextEmbeddingModelSettings } from "./LlamaCppTextEmbeddingModel.js";
 import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
+/**
+ * Creates an API configuration for the Llama.cpp server.
+ * It calls the API at http://127.0.0.1:8080 by default.
+ */
+export declare function Api(settings: PartialBaseUrlPartsApiConfigurationOptions): LlamaCppApiConfiguration;
 export declare function TextGenerator<CONTEXT_WINDOW_SIZE extends number>(settings?: LlamaCppCompletionModelSettings<CONTEXT_WINDOW_SIZE>): LlamaCppCompletionModel<CONTEXT_WINDOW_SIZE>;
 export declare function TextEmbedder(settings?: LlamaCppTextEmbeddingModelSettings): LlamaCppTextEmbeddingModel;
 export declare function Tokenizer(api?: ApiConfiguration): LlamaCppTokenizer;

package/model-provider/llamacpp/LlamaCppFacade.js

@@ -1,7 +1,14 @@
 import { LlamaCppApiConfiguration } from "./LlamaCppApiConfiguration.js";
-import { LlamaCppTextEmbeddingModel, } from "./LlamaCppTextEmbeddingModel.js";
 import { LlamaCppCompletionModel, } from "./LlamaCppCompletionModel.js";
+import { LlamaCppTextEmbeddingModel, } from "./LlamaCppTextEmbeddingModel.js";
 import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
+/**
+ * Creates an API configuration for the Llama.cpp server.
+ * It calls the API at http://127.0.0.1:8080 by default.
+ */
+export function Api(settings) {
+    return new LlamaCppApiConfiguration(settings);
+}
 export function TextGenerator(settings = {}) {
     return new LlamaCppCompletionModel(settings);
 }

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.cjs

@@ -4,6 +4,7 @@ exports.LlamaCppTextEmbeddingModel = void 0;
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const LlamaCppApiConfiguration_js_1 = require("./LlamaCppApiConfiguration.cjs");
 const LlamaCppError_js_1 = require("./LlamaCppError.cjs");
@@ -53,13 +54,18 @@ class LlamaCppTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Llama.cpp embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
+        const api = this.settings.api ?? new LlamaCppApiConfiguration_js_1.LlamaCppApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callLlamaCppEmbeddingAPI({
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                content: texts[0],
+            call: async () => (0, postToApi_js_1.postJsonToApi)({
+                url: api.assembleUrl(`/embedding`),
+                headers: api.headers,
+                body: { content: texts[0] },
+                failedResponseHandler: LlamaCppError_js_1.failedLlamaCppCallResponseHandler,
+                successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(llamaCppTextEmbeddingResponseSchema)),
+                abortSignal,
             }),
         });
     }
@@ -83,13 +89,3 @@ exports.LlamaCppTextEmbeddingModel = LlamaCppTextEmbeddingModel;
 const llamaCppTextEmbeddingResponseSchema = zod_1.z.object({
     embedding: zod_1.z.array(zod_1.z.number()),
 });
-async function callLlamaCppEmbeddingAPI({ api = new LlamaCppApiConfiguration_js_1.LlamaCppApiConfiguration(), abortSignal, content, }) {
-    return (0, postToApi_js_1.postJsonToApi)({
-        url: api.assembleUrl(`/embedding`),
-        headers: api.headers,
-        body: { content },
-        failedResponseHandler: LlamaCppError_js_1.failedLlamaCppCallResponseHandler,
-        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(llamaCppTextEmbeddingResponseSchema),
-        abortSignal,
-    });
-}

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { LlamaCppApiConfiguration } from "./LlamaCppApiConfiguration.js";
 import { failedLlamaCppCallResponseHandler } from "./LlamaCppError.js";
@@ -50,13 +51,18 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Llama.cpp embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
+        const api = this.settings.api ?? new LlamaCppApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callLlamaCppEmbeddingAPI({
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                content: texts[0],
+            call: async () => postJsonToApi({
+                url: api.assembleUrl(`/embedding`),
+                headers: api.headers,
+                body: { content: texts[0] },
+                failedResponseHandler: failedLlamaCppCallResponseHandler,
+                successfulResponseHandler: createJsonResponseHandler(zodSchema(llamaCppTextEmbeddingResponseSchema)),
+                abortSignal,
             }),
         });
     }
@@ -79,13 +85,3 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
 const llamaCppTextEmbeddingResponseSchema = z.object({
     embedding: z.array(z.number()),
 });
-async function callLlamaCppEmbeddingAPI({ api = new LlamaCppApiConfiguration(), abortSignal, content, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/embedding`),
-        headers: api.headers,
-        body: { content },
-        failedResponseHandler: failedLlamaCppCallResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler(llamaCppTextEmbeddingResponseSchema),
-        abortSignal,
-    });
-}