@sheepbun/yips 0.1.1

package/dist/llm/llama-client.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlamaClient = void 0;
+const CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
+const DEFAULT_TIMEOUT_MS = 30_000;
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function extractFirstChoice(payload) {
+    if (!isRecord(payload)) {
+        return null;
+    }
+    const choices = payload["choices"];
+    if (!Array.isArray(choices) || choices.length === 0) {
+        return null;
+    }
+    const first = choices[0];
+    return isRecord(first) ? first : null;
+}
+function extractMessageContent(choice) {
+    const message = choice["message"];
+    if (isRecord(message) && typeof message["content"] === "string") {
+        return message["content"];
+    }
+    return "";
+}
+function extractDeltaContent(choice) {
+    const delta = choice["delta"];
+    if (isRecord(delta) && typeof delta["content"] === "string") {
+        return delta["content"];
+    }
+    return "";
+}
+function parseStreamLine(line) {
+    if (!line.startsWith("data:")) {
+        return { done: false, token: "" };
+    }
+    const payload = line.slice("data:".length).trim();
+    if (payload.length === 0) {
+        return { done: false, token: "" };
+    }
+    if (payload === "[DONE]") {
+        return { done: true, token: "" };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        throw new Error(`Failed to parse streaming payload: ${payload.slice(0, 200)}`);
+    }
+    const choice = extractFirstChoice(parsed);
+    const usage = extractUsageTotals(parsed);
+    if (!choice) {
+        return { done: false, token: "", usage };
+    }
+    const token = extractDeltaContent(choice) || extractMessageContent(choice);
+    return { done: false, token, usage };
+}
+function extractUsageTotals(payload) {
+    if (!isRecord(payload)) {
+        return undefined;
+    }
+    const usage = payload["usage"];
+    if (!isRecord(usage)) {
+        return undefined;
+    }
+    const promptTokens = usage["prompt_tokens"];
+    const completionTokens = usage["completion_tokens"];
+    const totalTokens = usage["total_tokens"];
+    if (typeof promptTokens !== "number" ||
+        typeof completionTokens !== "number" ||
+        typeof totalTokens !== "number") {
+        return undefined;
+    }
+    if (promptTokens < 0 || completionTokens < 0 || totalTokens < 0) {
+        return undefined;
+    }
+    return { promptTokens, completionTokens, totalTokens };
+}
+async function readErrorBody(response) {
+    try {
+        return (await response.text()).trim();
+    }
+    catch {
+        return "";
+    }
+}
+class LlamaClient {
+    baseUrl;
+    model;
+    timeoutMs;
+    fetchImpl;
+    constructor(options) {
+        this.baseUrl = normalizeBaseUrl(options.baseUrl);
+        this.model = options.model.trim();
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    setModel(model) {
+        const next = model.trim();
+        if (next.length > 0) {
+            this.model = next;
+        }
+    }
+    getModel() {
+        return this.model;
+    }
+    async chat(messages, model = this.model) {
+        const payload = this.buildPayload(messages, model, false);
+        const response = await this.requestCompletion(payload);
+        const parsed = await response.json();
+        const choice = extractFirstChoice(parsed);
+        if (!choice) {
+            throw new Error("Chat completion response did not include choices.");
+        }
+        const content = extractMessageContent(choice);
+        if (content.length === 0) {
+            throw new Error("Chat completion response did not include assistant content.");
+        }
+        return {
+            text: content,
+            usage: extractUsageTotals(parsed)
+        };
+    }
+    async streamChat(messages, handlers, model = this.model) {
+        const payload = this.buildPayload(messages, model, true);
+        const response = await this.requestCompletion(payload);
+        if (!response.body) {
+            throw new Error("Streaming response body is unavailable.");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let content = "";
+        let streamDone = false;
+        let usage;
+        try {
+            while (!streamDone) {
+                const { value, done } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split(/\r?\n/);
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const result = parseStreamLine(line.trim());
+                    if (result.usage) {
+                        usage = result.usage;
+                    }
+                    if (result.token.length > 0) {
+                        content += result.token;
+                        handlers.onToken(result.token);
+                    }
+                    if (result.done) {
+                        streamDone = true;
+                        break;
+                    }
+                }
+            }
+            const finalChunk = decoder.decode();
+            if (finalChunk.length > 0) {
+                buffer += finalChunk;
+            }
+            if (!streamDone && buffer.trim().length > 0) {
+                const result = parseStreamLine(buffer.trim());
+                if (result.usage) {
+                    usage = result.usage;
+                }
+                if (result.token.length > 0) {
+                    content += result.token;
+                    handlers.onToken(result.token);
+                }
+            }
+            return { text: content, usage };
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    buildPayload(messages, model, stream) {
+        return {
+            model: model.trim() || this.model,
+            messages,
+            stream
+        };
+    }
+    async requestCompletion(payload) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        const endpoint = `${this.baseUrl}${CHAT_COMPLETIONS_PATH}`;
+        let response;
+        try {
+            response = await this.fetchImpl(endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json"
+                },
+                body: JSON.stringify(payload),
+                signal: controller.signal
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`llama.cpp request timed out after ${this.timeoutMs}ms.`);
+            }
+            throw new Error(`Failed to connect to llama.cpp at ${this.baseUrl}: ${toErrorMessage(error)}`);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        if (!response.ok) {
+            const details = await readErrorBody(response);
+            const suffix = details.length > 0 ? `: ${details}` : "";
+            throw new Error(`llama.cpp request failed (${response.status} ${response.statusText})${suffix}`);
+        }
+        return response;
+    }
+}
+exports.LlamaClient = LlamaClient;