modelfusion 0.0.44

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

@@ -0,0 +1,399 @@
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { DeltaEvent } from "../../model-function/generate-text/DeltaEvent.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { PromptMapping } from "../../prompt/PromptMapping.js";
+import { PromptMappingTextGenerationModel } from "../../prompt/PromptMappingTextGenerationModel.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
+export interface LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE extends number | undefined> extends TextGenerationModelSettings {
+    baseUrl?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+    tokenizerSettings?: {
+        retry?: RetryFunction;
+        throttle?: ThrottleFunction;
+    };
+    /**
+     * Specify the context window size of the model that you have loaded in your
+     * Llama.cpp server.
+     */
+    contextWindowSize?: CONTEXT_WINDOW_SIZE;
+    temperature?: number;
+    topK?: number;
+    topP?: number;
+    nPredict?: number;
+    nKeep?: number;
+    stop?: string[];
+    tfsZ?: number;
+    typicalP?: number;
+    repeatPenalty?: number;
+    repeatLastN?: number;
+    penalizeNl?: boolean;
+    mirostat?: number;
+    mirostatTau?: number;
+    mirostatEta?: number;
+    seed?: number;
+    ignoreEos?: boolean;
+    logitBias?: Array<[number, number | false]>;
+}
+export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends number | undefined> extends AbstractModel<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> implements TextGenerationModel<string, LlamaCppTextGenerationResponse, LlamaCppTextGenerationDelta, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> {
+    constructor(settings?: LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>);
+    readonly provider = "llamacpp";
+    get modelName(): null;
+    get contextWindowSize(): CONTEXT_WINDOW_SIZE;
+    readonly tokenizer: LlamaCppTokenizer;
+    callAPI<RESPONSE>(prompt: string, options: {
+        responseFormat: LlamaCppTextGenerationResponseFormatType<RESPONSE>;
+    } & FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<RESPONSE>;
+    countPromptTokens(prompt: string): Promise<number>;
+    generateTextResponse(prompt: string, options?: FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<{
+        model: string;
+        prompt: string;
+        content: string;
+        stop: true;
+        generation_settings: {
+            model: string;
+            stream: boolean;
+            seed: number;
+            stop: string[];
+            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;
+            temp: number;
+            tfs_z: number;
+            top_k: number;
+            top_p: number;
+            typical_p: number;
+        };
+        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_ms: number | null;
+            prompt_n: number;
+            prompt_per_second: number | null;
+            prompt_per_token_ms: number | null;
+        };
+        tokens_cached: number;
+        tokens_evaluated: number;
+        tokens_predicted: number;
+        truncated: boolean;
+    }>;
+    extractText(response: LlamaCppTextGenerationResponse): string;
+    generateDeltaStreamResponse(prompt: string, options?: FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
+    extractTextDelta(fullDelta: LlamaCppTextGenerationDelta): string | undefined;
+    mapPrompt<INPUT_PROMPT>(promptMapping: PromptMapping<INPUT_PROMPT, string>): PromptMappingTextGenerationModel<INPUT_PROMPT, string, LlamaCppTextGenerationResponse, LlamaCppTextGenerationDelta, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
+    withSettings(additionalSettings: Partial<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): this;
+    get maxCompletionTokens(): number | undefined;
+    withMaxCompletionTokens(maxCompletionTokens: number): this;
+    withStopTokens(stopTokens: string[]): this;
+}
+declare const llamaCppTextGenerationResponseSchema: 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;
+        temp: 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;
+        seed: number;
+        stop: string[];
+        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;
+        temp: number;
+        tfs_z: number;
+        top_k: number;
+        top_p: number;
+        typical_p: number;
+    }, {
+        model: string;
+        stream: boolean;
+        seed: number;
+        stop: string[];
+        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;
+        temp: number;
+        tfs_z: number;
+        top_k: number;
+        top_p: number;
+        typical_p: number;
+    }>;
+    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.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_ms: number | null;
+        prompt_n: number;
+        prompt_per_second: number | null;
+        prompt_per_token_ms: number | null;
+    }, {
+        predicted_ms: number;
+        predicted_n: number;
+        predicted_per_second: number | null;
+        predicted_per_token_ms: number | null;
+        prompt_ms: number | null;
+        prompt_n: number;
+        prompt_per_second: number | null;
+        prompt_per_token_ms: number | null;
+    }>;
+    tokens_cached: z.ZodNumber;
+    tokens_evaluated: z.ZodNumber;
+    tokens_predicted: z.ZodNumber;
+    truncated: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    prompt: string;
+    content: string;
+    stop: true;
+    generation_settings: {
+        model: string;
+        stream: boolean;
+        seed: number;
+        stop: string[];
+        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;
+        temp: number;
+        tfs_z: number;
+        top_k: number;
+        top_p: number;
+        typical_p: number;
+    };
+    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_ms: number | null;
+        prompt_n: number;
+        prompt_per_second: number | null;
+        prompt_per_token_ms: number | null;
+    };
+    tokens_cached: number;
+    tokens_evaluated: number;
+    tokens_predicted: number;
+    truncated: boolean;
+}, {
+    model: string;
+    prompt: string;
+    content: string;
+    stop: true;
+    generation_settings: {
+        model: string;
+        stream: boolean;
+        seed: number;
+        stop: string[];
+        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;
+        temp: number;
+        tfs_z: number;
+        top_k: number;
+        top_p: number;
+        typical_p: number;
+    };
+    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_ms: number | null;
+        prompt_n: number;
+        prompt_per_second: number | null;
+        prompt_per_token_ms: number | null;
+    };
+    tokens_cached: number;
+    tokens_evaluated: number;
+    tokens_predicted: number;
+    truncated: boolean;
+}>;
+export type LlamaCppTextGenerationResponse = z.infer<typeof llamaCppTextGenerationResponseSchema>;
+export type LlamaCppTextGenerationDelta = {
+    content: string;
+    isComplete: boolean;
+    delta: string;
+};
+export type LlamaCppTextGenerationResponseFormatType<T> = {
+    stream: boolean;
+    handler: ResponseHandler<T>;
+};
+export declare const LlamaCppTextGenerationResponseFormat: {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false;
+        handler: ResponseHandler<{
+            model: string;
+            prompt: string;
+            content: string;
+            stop: true;
+            generation_settings: {
+                model: string;
+                stream: boolean;
+                seed: number;
+                stop: string[];
+                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;
+                temp: number;
+                tfs_z: number;
+                top_k: number;
+                top_p: number;
+                typical_p: number;
+            };
+            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_ms: number | null;
+                prompt_n: number;
+                prompt_per_second: number | null;
+                prompt_per_token_ms: number | null;
+            };
+            tokens_cached: number;
+            tokens_evaluated: number;
+            tokens_predicted: number;
+            truncated: boolean;
+        }>;
+    };
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true;
+        handler: ({ response }: {
+            response: Response;
+        }) => Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
+    };
+};
+export {};

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -0,0 +1,238 @@
+import SecureJSON from "secure-json-parse";
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { AsyncQueue } from "../../model-function/generate-text/AsyncQueue.js";
+import { parseEventSourceReadableStream } from "../../model-function/generate-text/parseEventSourceReadableStream.js";
+import { PromptMappingTextGenerationModel } from "../../prompt/PromptMappingTextGenerationModel.js";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedLlamaCppCallResponseHandler } from "./LlamaCppError.js";
+import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
+export class LlamaCppTextGenerationModel extends AbstractModel {
+    constructor(settings = {}) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "llamacpp"
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tokenizer = new LlamaCppTokenizer({
+            baseUrl: this.settings.baseUrl,
+            retry: this.settings.tokenizerSettings?.retry,
+            throttle: this.settings.tokenizerSettings?.throttle,
+        });
+    }
+    get modelName() {
+        return null;
+    }
+    get contextWindowSize() {
+        return this.settings.contextWindowSize;
+    }
+    async callAPI(prompt, options) {
+        const { run, settings, responseFormat } = options;
+        const callSettings = Object.assign(this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            prompt,
+            responseFormat,
+        });
+        return callWithRetryAndThrottle({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callLlamaCppTextGenerationAPI(callSettings),
+        });
+    }
+    async countPromptTokens(prompt) {
+        const tokens = await this.tokenizer.tokenize(prompt);
+        return tokens.length;
+    }
+    generateTextResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: LlamaCppTextGenerationResponseFormat.json,
+        });
+    }
+    extractText(response) {
+        return response.content;
+    }
+    generateDeltaStreamResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: LlamaCppTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    extractTextDelta(fullDelta) {
+        return fullDelta.delta;
+    }
+    mapPrompt(promptMapping) {
+        return new PromptMappingTextGenerationModel({
+            model: this.withStopTokens(promptMapping.stopTokens),
+            promptMapping,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new LlamaCppTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+    get maxCompletionTokens() {
+        return this.settings.nPredict;
+    }
+    withMaxCompletionTokens(maxCompletionTokens) {
+        return this.withSettings({ nPredict: maxCompletionTokens });
+    }
+    withStopTokens(stopTokens) {
+        return this.withSettings({ stop: stopTokens });
+    }
+}
+const llamaCppTextGenerationResponseSchema = z.object({
+    content: z.string(),
+    stop: z.literal(true),
+    generation_settings: z.object({
+        frequency_penalty: z.number(),
+        ignore_eos: z.boolean(),
+        logit_bias: z.array(z.number()),
+        mirostat: z.number(),
+        mirostat_eta: z.number(),
+        mirostat_tau: z.number(),
+        model: z.string(),
+        n_ctx: z.number(),
+        n_keep: z.number(),
+        n_predict: z.number(),
+        n_probs: z.number(),
+        penalize_nl: z.boolean(),
+        presence_penalty: z.number(),
+        repeat_last_n: z.number(),
+        repeat_penalty: z.number(),
+        seed: z.number(),
+        stop: z.array(z.string()),
+        stream: z.boolean(),
+        temp: z.number(),
+        tfs_z: z.number(),
+        top_k: z.number(),
+        top_p: z.number(),
+        typical_p: z.number(),
+    }),
+    model: z.string(),
+    prompt: z.string(),
+    stopped_eos: z.boolean(),
+    stopped_limit: z.boolean(),
+    stopped_word: z.boolean(),
+    stopping_word: z.string(),
+    timings: z.object({
+        predicted_ms: z.number(),
+        predicted_n: z.number(),
+        predicted_per_second: z.number().nullable(),
+        predicted_per_token_ms: z.number().nullable(),
+        prompt_ms: z.number().nullable(),
+        prompt_n: z.number(),
+        prompt_per_second: z.number().nullable(),
+        prompt_per_token_ms: z.number().nullable(),
+    }),
+    tokens_cached: z.number(),
+    tokens_evaluated: z.number(),
+    tokens_predicted: z.number(),
+    truncated: z.boolean(),
+});
+const llamaCppTextStreamingResponseSchema = z.discriminatedUnion("stop", [
+    z.object({
+        content: z.string(),
+        stop: z.literal(false),
+    }),
+    llamaCppTextGenerationResponseSchema,
+]);
+async function callLlamaCppTextGenerationAPI({ baseUrl = "http://127.0.0.1:8080", abortSignal, responseFormat, prompt, temperature, topK, topP, nPredict, nKeep, stop, tfsZ, typicalP, repeatPenalty, repeatLastN, penalizeNl, mirostat, mirostatTau, mirostatEta, seed, ignoreEos, logitBias, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/completion`,
+        body: {
+            stream: responseFormat.stream,
+            prompt,
+            temperature,
+            top_k: topK,
+            top_p: topP,
+            n_predict: nPredict,
+            n_keep: nKeep,
+            stop,
+            tfs_z: tfsZ,
+            typical_p: typicalP,
+            repeat_penalty: repeatPenalty,
+            repeat_last_n: repeatLastN,
+            penalize_nl: penalizeNl,
+            mirostat,
+            mirostat_tau: mirostatTau,
+            mirostat_eta: mirostatEta,
+            seed,
+            ignore_eos: ignoreEos,
+            logit_bias: logitBias,
+        },
+        failedResponseHandler: failedLlamaCppCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+async function createLlamaCppFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue();
+    let content = "";
+    // process the stream asynchonously (no 'await' on purpose):
+    parseEventSourceReadableStream({
+        stream,
+        callback: (event) => {
+            if (event.type !== "event") {
+                return;
+            }
+            const data = event.data;
+            try {
+                const json = SecureJSON.parse(data);
+                const parseResult = llamaCppTextStreamingResponseSchema.safeParse(json);
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    queue.close();
+                    return;
+                }
+                const event = parseResult.data;
+                content += event.content;
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content,
+                        isComplete: event.stop,
+                        delta: event.content,
+                    },
+                });
+                if (event.stop) {
+                    queue.close();
+                }
+            }
+            catch (error) {
+                queue.push({ type: "error", error });
+                queue.close();
+                return;
+            }
+        },
+    });
+    return queue;
+}
+export const LlamaCppTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: createJsonResponseHandler(llamaCppTextGenerationResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createLlamaCppFullDeltaIterableQueue(response.body),
+    },
+};

package/model-provider/llamacpp/LlamaCppTokenizer.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlamaCppTokenizer = void 0;
+const zod_1 = __importDefault(require("zod"));
+const callWithRetryAndThrottle_js_1 = require("../../util/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../util/api/postToApi.cjs");
+const LlamaCppError_js_1 = require("./LlamaCppError.cjs");
+/**
+ * Tokenizer for LlamaCpp.
+
+ * @example
+ * const tokenizer = new LlamaCppTokenizer();
+ *
+ * const text = "At first, Nox didn't know what to do with the pup.";
+ *
+ * const tokenCount = await countTokens(tokenizer, text);
+ * const tokens = await tokenizer.tokenize(text);
+ * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
+ * const reconstructedText = await tokenizer.detokenize(tokens);
+ */
+class LlamaCppTokenizer {
+    constructor(settings = {}) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+    }
+    async callTokenizeAPI(text, context) {
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callLlamaCppTokenizeAPI({
+                abortSignal: context?.abortSignal,
+                text,
+                ...this.settings,
+            }),
+        });
+    }
+    async tokenize(text) {
+        const response = await this.callTokenizeAPI(text);
+        return response.tokens;
+    }
+}
+exports.LlamaCppTokenizer = LlamaCppTokenizer;
+const llamaCppTokenizationResponseSchema = zod_1.default.object({
+    tokens: zod_1.default.array(zod_1.default.number()),
+});
+async function callLlamaCppTokenizeAPI({ baseUrl = "http://127.0.0.1:8080", abortSignal, text, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/tokenize`,
+        body: {
+            content: text,
+        },
+        failedResponseHandler: LlamaCppError_js_1.failedLlamaCppCallResponseHandler,
+        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(llamaCppTokenizationResponseSchema),
+        abortSignal,
+    });
+}