mono-pilot 0.2.10 → 0.2.13

package/dist/src/memory/embeddings/input-limits.js

@@ -0,0 +1,48 @@
+// Helpers for enforcing embedding model input size limits.
+// Tokenizers operate over bytes; token_count <= utf8_byte_length.
+export function estimateUtf8Bytes(text) {
+    if (!text)
+        return 0;
+    return Buffer.byteLength(text, "utf8");
+}
+export function splitTextToUtf8ByteLimit(text, maxUtf8Bytes) {
+    if (maxUtf8Bytes <= 0)
+        return [text];
+    if (estimateUtf8Bytes(text) <= maxUtf8Bytes)
+        return [text];
+    const parts = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        let low = cursor + 1;
+        let high = Math.min(text.length, cursor + maxUtf8Bytes);
+        let best = cursor;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const bytes = estimateUtf8Bytes(text.slice(cursor, mid));
+            if (bytes <= maxUtf8Bytes) {
+                best = mid;
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        if (best <= cursor) {
+            best = Math.min(text.length, cursor + 1);
+        }
+        if (best < text.length &&
+            best > cursor &&
+            text.charCodeAt(best - 1) >= 0xd800 &&
+            text.charCodeAt(best - 1) <= 0xdbff &&
+            text.charCodeAt(best) >= 0xdc00 &&
+            text.charCodeAt(best) <= 0xdfff) {
+            best -= 1;
+        }
+        const part = text.slice(cursor, best);
+        if (!part)
+            break;
+        parts.push(part);
+        cursor = best;
+    }
+    return parts;
+}

package/dist/src/memory/embeddings/local.js

@@ -0,0 +1,108 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+function normalizeEmbedding(vector) {
+    const sanitized = vector.map((value) => (Number.isFinite(value) ? value : 0));
+    const magnitude = Math.sqrt(sanitized.reduce((sum, value) => sum + value * value, 0));
+    if (magnitude < 1e-10) {
+        return sanitized;
+    }
+    return sanitized.map((value) => value / magnitude);
+}
+export async function createLocalEmbeddingProvider(params) {
+    const modelPath = params.modelPath?.trim() || "hf:gpustack/bge-m3-GGUF/bge-m3-Q8_0.gguf";
+    const modelCacheDir = params.modelCacheDir?.trim() || join(homedir(), ".mono-pilot", "models");
+    const nodeLlamaCpp = await import("node-llama-cpp");
+    const { getLlama, resolveModelFile } = nodeLlamaCpp;
+    const logLevel = nodeLlamaCpp.LlamaLogLevel?.error;
+    let llama = null;
+    let model = null;
+    let context = null;
+    let closing = false;
+    let inFlightRequests = 0;
+    let disposePromise = null;
+    const idleWaiters = new Set();
+    const notifyIfIdle = () => {
+        if (inFlightRequests !== 0) {
+            return;
+        }
+        for (const resolve of idleWaiters) {
+            resolve();
+        }
+        idleWaiters.clear();
+    };
+    const waitForIdle = async () => {
+        if (inFlightRequests === 0) {
+            return;
+        }
+        await new Promise((resolve) => {
+            idleWaiters.add(resolve);
+        });
+    };
+    const runWithInFlightTracking = async (operation) => {
+        if (closing) {
+            throw new Error("embedding provider is closing");
+        }
+        inFlightRequests += 1;
+        try {
+            return await operation();
+        }
+        finally {
+            inFlightRequests = Math.max(0, inFlightRequests - 1);
+            notifyIfIdle();
+        }
+    };
+    const ensureContext = async () => {
+        if (!llama) {
+            llama = await getLlama({ logLevel: logLevel ?? "error" });
+        }
+        if (!model) {
+            const resolved = await resolveModelFile(modelPath, modelCacheDir);
+            model = await llama.loadModel({ modelPath: resolved });
+        }
+        if (!context) {
+            context = await model.createEmbeddingContext();
+        }
+        return context;
+    };
+    return {
+        id: "local",
+        model: modelPath,
+        embedQuery: async (text) => {
+            return runWithInFlightTracking(async () => {
+                const ctx = await ensureContext();
+                const embedding = await ctx.getEmbeddingFor(text);
+                return normalizeEmbedding(Array.from(embedding.vector));
+            });
+        },
+        embedBatch: async (texts) => {
+            return runWithInFlightTracking(async () => {
+                const ctx = await ensureContext();
+                const embeddings = await Promise.all(texts.map(async (text) => {
+                    const embedding = await ctx.getEmbeddingFor(text);
+                    return normalizeEmbedding(Array.from(embedding.vector));
+                }));
+                return embeddings;
+            });
+        },
+        dispose: async () => {
+            if (disposePromise) {
+                await disposePromise;
+                return;
+            }
+            closing = true;
+            disposePromise = (async () => {
+                await waitForIdle();
+                if (context) {
+                    await context.dispose();
+                    context = null;
+                }
+                if (model) {
+                    await model.dispose();
+                    model = null;
+                }
+                llama = null;
+            })();
+            await disposePromise;
+        },
+    };
+}

package/dist/src/memory/embeddings/types.js

@@ -0,0 +1 @@
+export {};