modelfusion 0.0.44

package/model-provider/huggingface/HuggingFaceError.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failedHuggingFaceCallResponseHandler = exports.HuggingFaceError = exports.huggingFaceErrorDataSchema = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const ApiCallError_js_1 = require("../../util/api/ApiCallError.cjs");
+exports.huggingFaceErrorDataSchema = zod_1.z.object({
+    error: zod_1.z.string(),
+});
+class HuggingFaceError 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.HuggingFaceError = HuggingFaceError;
+const failedHuggingFaceCallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    try {
+        const parsedError = exports.huggingFaceErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
+        return new HuggingFaceError({
+            url,
+            requestBodyValues,
+            statusCode: response.status,
+            data: parsedError,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error instanceof ApiCallError_js_1.ApiCallError) {
+                throw error;
+            }
+        }
+        throw new ApiCallError_js_1.ApiCallError({
+            message: responseBody,
+            cause: error,
+            statusCode: response.status,
+            url,
+            requestBodyValues,
+        });
+    }
+};
+exports.failedHuggingFaceCallResponseHandler = failedHuggingFaceCallResponseHandler;

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+export declare const huggingFaceErrorDataSchema: z.ZodObject<{
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+}, {
+    error: string;
+}>;
+export type HuggingFaceErrorData = z.infer<typeof huggingFaceErrorDataSchema>;
+export declare class HuggingFaceError extends ApiCallError {
+    readonly data: HuggingFaceErrorData;
+    constructor({ data, statusCode, url, requestBodyValues, message, }: {
+        message?: string;
+        statusCode: number;
+        url: string;
+        requestBodyValues: unknown;
+        data: HuggingFaceErrorData;
+    });
+}
+export declare const failedHuggingFaceCallResponseHandler: ResponseHandler<ApiCallError>;

package/model-provider/huggingface/HuggingFaceError.js

@@ -0,0 +1,44 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+export const huggingFaceErrorDataSchema = z.object({
+    error: z.string(),
+});
+export class HuggingFaceError 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 failedHuggingFaceCallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    try {
+        const parsedError = huggingFaceErrorDataSchema.parse(SecureJSON.parse(responseBody));
+        return new HuggingFaceError({
+            url,
+            requestBodyValues,
+            statusCode: response.status,
+            data: parsedError,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error instanceof ApiCallError) {
+                throw error;
+            }
+        }
+        throw new ApiCallError({
+            message: responseBody,
+            cause: error,
+            statusCode: response.status,
+            url,
+            requestBodyValues,
+        });
+    }
+};

package/model-provider/huggingface/HuggingFaceTextGenerationModel.cjs

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HuggingFaceTextGenerationModel = void 0;
+const zod_1 = __importDefault(require("zod"));
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const callWithRetryAndThrottle_js_1 = require("../../util/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../util/api/postToApi.cjs");
+const HuggingFaceError_js_1 = require("./HuggingFaceError.cjs");
+const PromptMappingTextGenerationModel_js_1 = require("../../prompt/PromptMappingTextGenerationModel.cjs");
+/**
+ * Create a text generation model that calls a Hugging Face Inference API Text Generation Task.
+ *
+ * @see https://huggingface.co/docs/api-inference/detailed_parameters#text-generation-task
+ *
+ * @example
+ * const model = new HuggingFaceTextGenerationModel({
+ *   model: "tiiuae/falcon-7b",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
+ * });
+ *
+ * const { text } = await generateText(
+ *   model,
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+class HuggingFaceTextGenerationModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "huggingface"
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "generateDeltaStreamResponse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "extractTextDelta", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.HUGGINGFACE_API_KEY;
+        if (apiKey == null) {
+            throw new Error("No Hugging Face API key provided. Pass it in the constructor or set the HUGGINGFACE_API_KEY environment variable.");
+        }
+        return apiKey;
+    }
+    async callAPI(prompt, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+            options: {
+                useCache: true,
+                waitForModel: true,
+            },
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            inputs: prompt,
+        });
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callHuggingFaceTextGenerationAPI(callSettings),
+        });
+    }
+    generateTextResponse(prompt, options) {
+        return this.callAPI(prompt, options);
+    }
+    extractText(response) {
+        return response[0].generated_text;
+    }
+    mapPrompt(promptMapping) {
+        return new PromptMappingTextGenerationModel_js_1.PromptMappingTextGenerationModel({
+            model: this,
+            promptMapping,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new HuggingFaceTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+    get maxCompletionTokens() {
+        return this.settings.maxNewTokens;
+    }
+    withMaxCompletionTokens(maxCompletionTokens) {
+        return this.withSettings({ maxNewTokens: maxCompletionTokens });
+    }
+    withStopTokens() {
+        // stop tokens are not supported by the HuggingFace API
+        return this;
+    }
+}
+exports.HuggingFaceTextGenerationModel = HuggingFaceTextGenerationModel;
+const huggingFaceTextGenerationResponseSchema = zod_1.default.array(zod_1.default.object({
+    generated_text: zod_1.default.string(),
+}));
+/**
+ * Call a Hugging Face Inference API Text Generation Task to generate a text completion for the given prompt.
+ *
+ * @see https://huggingface.co/docs/api-inference/detailed_parameters#text-generation-task
+ *
+ * @example
+ * const response = await callHuggingFaceTextGenerationAPI({
+ *   apiKey: HUGGINGFACE_API_KEY,
+ *   model: "tiiuae/falcon-7b",
+ *   inputs: "Write a short story about a robot learning to love:\n\n",
+ *   temperature: 700,
+ *   maxNewTokens: 500,
+ *   options: {
+ *     waitForModel: true,
+ *   },
+ * });
+ *
+ * console.log(response[0].generated_text);
+ */
+async function callHuggingFaceTextGenerationAPI({ baseUrl = "https://api-inference.huggingface.co/models", abortSignal, apiKey, model, inputs, topK, topP, temperature, repetitionPenalty, maxNewTokens, maxTime, numReturnSequences, doSample, options, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/${model}`,
+        apiKey,
+        body: {
+            inputs,
+            top_k: topK,
+            top_p: topP,
+            temperature,
+            repetition_penalty: repetitionPenalty,
+            max_new_tokens: maxNewTokens,
+            max_time: maxTime,
+            num_return_sequences: numReturnSequences,
+            do_sample: doSample,
+            options: options
+                ? {
+                    use_cache: options?.useCache,
+                    wait_for_model: options?.waitForModel,
+                }
+                : undefined,
+        },
+        failedResponseHandler: HuggingFaceError_js_1.failedHuggingFaceCallResponseHandler,
+        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(huggingFaceTextGenerationResponseSchema),
+        abortSignal,
+    });
+}

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

@@ -0,0 +1,75 @@
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+import { PromptMapping } from "../../prompt/PromptMapping.js";
+import { PromptMappingTextGenerationModel } from "../../prompt/PromptMappingTextGenerationModel.js";
+export interface HuggingFaceTextGenerationModelSettings extends TextGenerationModelSettings {
+    model: string;
+    baseUrl?: string;
+    apiKey?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+    topK?: number;
+    topP?: number;
+    temperature?: number;
+    repetitionPenalty?: number;
+    maxNewTokens?: number;
+    maxTime?: number;
+    numReturnSequences?: number;
+    doSample?: boolean;
+    options?: {
+        useCache?: boolean;
+        waitForModel?: boolean;
+    };
+}
+/**
+ * Create a text generation model that calls a Hugging Face Inference API Text Generation Task.
+ *
+ * @see https://huggingface.co/docs/api-inference/detailed_parameters#text-generation-task
+ *
+ * @example
+ * const model = new HuggingFaceTextGenerationModel({
+ *   model: "tiiuae/falcon-7b",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
+ * });
+ *
+ * const { text } = await generateText(
+ *   model,
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+export declare class HuggingFaceTextGenerationModel extends AbstractModel<HuggingFaceTextGenerationModelSettings> implements TextGenerationModel<string, HuggingFaceTextGenerationResponse, undefined, HuggingFaceTextGenerationModelSettings> {
+    constructor(settings: HuggingFaceTextGenerationModelSettings);
+    readonly provider = "huggingface";
+    get modelName(): string;
+    readonly contextWindowSize: undefined;
+    readonly tokenizer: undefined;
+    private get apiKey();
+    callAPI(prompt: string, options?: FunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<HuggingFaceTextGenerationResponse>;
+    readonly countPromptTokens: undefined;
+    generateTextResponse(prompt: string, options?: FunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<{
+        generated_text: string;
+    }[]>;
+    extractText(response: HuggingFaceTextGenerationResponse): string;
+    generateDeltaStreamResponse: undefined;
+    extractTextDelta: undefined;
+    mapPrompt<INPUT_PROMPT>(promptMapping: PromptMapping<INPUT_PROMPT, string>): PromptMappingTextGenerationModel<INPUT_PROMPT, string, HuggingFaceTextGenerationResponse, undefined, HuggingFaceTextGenerationModelSettings, this>;
+    withSettings(additionalSettings: Partial<HuggingFaceTextGenerationModelSettings>): this;
+    get maxCompletionTokens(): number | undefined;
+    withMaxCompletionTokens(maxCompletionTokens: number): this;
+    withStopTokens(): this;
+}
+declare const huggingFaceTextGenerationResponseSchema: z.ZodArray<z.ZodObject<{
+    generated_text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    generated_text: string;
+}, {
+    generated_text: string;
+}>, "many">;
+export type HuggingFaceTextGenerationResponse = z.infer<typeof huggingFaceTextGenerationResponseSchema>;
+export {};

package/model-provider/huggingface/HuggingFaceTextGenerationModel.js

@@ -0,0 +1,167 @@
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedHuggingFaceCallResponseHandler } from "./HuggingFaceError.js";
+import { PromptMappingTextGenerationModel } from "../../prompt/PromptMappingTextGenerationModel.js";
+/**
+ * Create a text generation model that calls a Hugging Face Inference API Text Generation Task.
+ *
+ * @see https://huggingface.co/docs/api-inference/detailed_parameters#text-generation-task
+ *
+ * @example
+ * const model = new HuggingFaceTextGenerationModel({
+ *   model: "tiiuae/falcon-7b",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
+ * });
+ *
+ * const { text } = await generateText(
+ *   model,
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+export class HuggingFaceTextGenerationModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "huggingface"
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "generateDeltaStreamResponse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "extractTextDelta", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.HUGGINGFACE_API_KEY;
+        if (apiKey == null) {
+            throw new Error("No Hugging Face API key provided. Pass it in the constructor or set the HUGGINGFACE_API_KEY environment variable.");
+        }
+        return apiKey;
+    }
+    async callAPI(prompt, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+            options: {
+                useCache: true,
+                waitForModel: true,
+            },
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            inputs: prompt,
+        });
+        return callWithRetryAndThrottle({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callHuggingFaceTextGenerationAPI(callSettings),
+        });
+    }
+    generateTextResponse(prompt, options) {
+        return this.callAPI(prompt, options);
+    }
+    extractText(response) {
+        return response[0].generated_text;
+    }
+    mapPrompt(promptMapping) {
+        return new PromptMappingTextGenerationModel({
+            model: this,
+            promptMapping,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new HuggingFaceTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+    get maxCompletionTokens() {
+        return this.settings.maxNewTokens;
+    }
+    withMaxCompletionTokens(maxCompletionTokens) {
+        return this.withSettings({ maxNewTokens: maxCompletionTokens });
+    }
+    withStopTokens() {
+        // stop tokens are not supported by the HuggingFace API
+        return this;
+    }
+}
+const huggingFaceTextGenerationResponseSchema = z.array(z.object({
+    generated_text: z.string(),
+}));
+/**
+ * Call a Hugging Face Inference API Text Generation Task to generate a text completion for the given prompt.
+ *
+ * @see https://huggingface.co/docs/api-inference/detailed_parameters#text-generation-task
+ *
+ * @example
+ * const response = await callHuggingFaceTextGenerationAPI({
+ *   apiKey: HUGGINGFACE_API_KEY,
+ *   model: "tiiuae/falcon-7b",
+ *   inputs: "Write a short story about a robot learning to love:\n\n",
+ *   temperature: 700,
+ *   maxNewTokens: 500,
+ *   options: {
+ *     waitForModel: true,
+ *   },
+ * });
+ *
+ * console.log(response[0].generated_text);
+ */
+async function callHuggingFaceTextGenerationAPI({ baseUrl = "https://api-inference.huggingface.co/models", abortSignal, apiKey, model, inputs, topK, topP, temperature, repetitionPenalty, maxNewTokens, maxTime, numReturnSequences, doSample, options, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/${model}`,
+        apiKey,
+        body: {
+            inputs,
+            top_k: topK,
+            top_p: topP,
+            temperature,
+            repetition_penalty: repetitionPenalty,
+            max_new_tokens: maxNewTokens,
+            max_time: maxTime,
+            num_return_sequences: numReturnSequences,
+            do_sample: doSample,
+            options: options
+                ? {
+                    use_cache: options?.useCache,
+                    wait_for_model: options?.waitForModel,
+                }
+                : undefined,
+        },
+        failedResponseHandler: failedHuggingFaceCallResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(huggingFaceTextGenerationResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/huggingface/index.cjs

@@ -0,0 +1,20 @@
+"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 });
+exports.HuggingFaceError = void 0;
+var HuggingFaceError_js_1 = require("./HuggingFaceError.cjs");
+Object.defineProperty(exports, "HuggingFaceError", { enumerable: true, get: function () { return HuggingFaceError_js_1.HuggingFaceError; } });
+__exportStar(require("./HuggingFaceTextGenerationModel.cjs"), exports);

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

@@ -0,0 +1,2 @@
+export { HuggingFaceError, HuggingFaceErrorData } from "./HuggingFaceError.js";
+export * from "./HuggingFaceTextGenerationModel.js";

package/model-provider/huggingface/index.js

@@ -0,0 +1,2 @@
+export { HuggingFaceError } from "./HuggingFaceError.js";
+export * from "./HuggingFaceTextGenerationModel.js";

package/model-provider/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("./automatic1111/index.cjs"), exports);
+__exportStar(require("./cohere/index.cjs"), exports);
+__exportStar(require("./huggingface/index.cjs"), exports);
+__exportStar(require("./llamacpp/index.cjs"), exports);
+__exportStar(require("./openai/index.cjs"), exports);
+__exportStar(require("./stability/index.cjs"), exports);

package/model-provider/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./automatic1111/index.js";
+export * from "./cohere/index.js";
+export * from "./huggingface/index.js";
+export * from "./llamacpp/index.js";
+export * from "./openai/index.js";
+export * from "./stability/index.js";

package/model-provider/index.js

@@ -0,0 +1,6 @@
+export * from "./automatic1111/index.js";
+export * from "./cohere/index.js";
+export * from "./huggingface/index.js";
+export * from "./llamacpp/index.js";
+export * from "./openai/index.js";
+export * from "./stability/index.js";

package/model-provider/llamacpp/LlamaCppError.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failedLlamaCppCallResponseHandler = exports.LlamaCppError = exports.llamaCppErrorDataSchema = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const ApiCallError_js_1 = require("../../util/api/ApiCallError.cjs");
+exports.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 }) => {
+    const responseBody = await response.text();
+    try {
+        const parsedError = exports.llamaCppErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
+        return new LlamaCppError({
+            url,
+            requestBodyValues,
+            statusCode: response.status,
+            data: parsedError,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error instanceof ApiCallError_js_1.ApiCallError) {
+                throw error;
+            }
+        }
+        throw new ApiCallError_js_1.ApiCallError({
+            message: responseBody,
+            cause: error,
+            statusCode: response.status,
+            url,
+            requestBodyValues,
+        });
+    }
+};
+exports.failedLlamaCppCallResponseHandler = failedLlamaCppCallResponseHandler;

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+export declare const llamaCppErrorDataSchema: z.ZodObject<{
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+}, {
+    error: string;
+}>;
+export type LlamaCppErrorData = z.infer<typeof llamaCppErrorDataSchema>;
+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>;