@meechi-ai/core 1.0.0

package/dist/lib/ai/embeddings.js

@@ -0,0 +1,128 @@
+// Web Worker Management for RAG
+// Isolating Transformers.js in a worker prevents environment crashes in Next.js/Turbopack
+import { gpuLock } from './gpu-lock';
+let worker = null;
+let terminateTimer = null;
+const pendingRequests = new Map();
+function terminateWorker() {
+    if (worker) {
+        console.log("[RAG] Auto-terminating worker to save resources...");
+        worker.terminate();
+        worker = null;
+    }
+}
+function getWorker() {
+    if (typeof window === 'undefined')
+        return null;
+    // Reset timer on access
+    if (terminateTimer)
+        clearTimeout(terminateTimer);
+    terminateTimer = setTimeout(terminateWorker, 30000); // 30s idle timeout
+    if (worker)
+        return worker;
+    try {
+        console.log("[RAG] Initializing AI Web Worker...");
+        // Next.js standard way to load workers
+        worker = new Worker(new URL('./worker.ts', import.meta.url));
+        worker.onmessage = (event) => {
+            const { id, embedding, error } = event.data;
+            const handler = pendingRequests.get(id);
+            if (!handler)
+                return;
+            pendingRequests.delete(id);
+            if (error) {
+                handler.reject(new Error(error));
+            }
+            else {
+                handler.resolve(embedding);
+            }
+        };
+        worker.onerror = (err) => {
+            console.error("[RAG] Worker Error:", err);
+            // If worker crashes, clear it so next retry spawns new one
+            worker = null;
+        };
+        return worker;
+    }
+    catch (e) {
+        console.error("[RAG] Failed to initialize worker:", e);
+        return null;
+    }
+}
+/**
+ * Generates an embedding for a string of text.
+ * Now offloads to a Web Worker to ensure stability and UI responsiveness.
+ * PROTECTED BY GPU LOCK to prevent LLM/RAG collisions.
+ */
+export async function generateEmbedding(text) {
+    // 1. Acquire Lock (Waits if Chat is active)
+    await gpuLock.acquire('RAG');
+    try {
+        const aiWorker = getWorker();
+        if (!aiWorker) {
+            throw new Error("RAG Worker not available (SSR or Init Failure)");
+        }
+        const id = Math.random().toString(36).substring(7);
+        return await new Promise((resolve, reject) => {
+            pendingRequests.set(id, { resolve, reject });
+            aiWorker.postMessage({ id, text });
+            // Timeout just in case
+            setTimeout(() => {
+                if (pendingRequests.has(id)) {
+                    pendingRequests.delete(id);
+                    reject(new Error("Embedding generation timed out"));
+                }
+            }, 30000);
+        });
+    }
+    finally {
+        // 2. Release Lock (Immediately allow Chat to resume)
+        gpuLock.release();
+    }
+}
+/**
+ * Splits text into semantic chunks.
+ * Standard Recursive Character splitting logic.
+ */
+export function chunkText(text, maxChunkSize = 1000, overlap = 200) {
+    if (!text)
+        return [];
+    // Split into paragraphs first
+    const paragraphs = text.split(/\n\s*\n/);
+    const chunks = [];
+    let currentChunk = "";
+    for (const para of paragraphs) {
+        if ((currentChunk.length + para.length) <= maxChunkSize) {
+            currentChunk += (currentChunk ? "\n\n" : "") + para;
+        }
+        else {
+            if (currentChunk)
+                chunks.push(currentChunk);
+            currentChunk = para;
+            // If a single paragraph is still too big, hard cut it
+            if (currentChunk.length > maxChunkSize) {
+                // ... (simplified cut for now)
+                const sub = currentChunk.substring(0, maxChunkSize);
+                chunks.push(sub);
+                currentChunk = currentChunk.substring(maxChunkSize - overlap);
+            }
+        }
+    }
+    if (currentChunk)
+        chunks.push(currentChunk);
+    return chunks;
+}
+/**
+ * Calculates cosine similarity between two vectors.
+ */
+export function cosineSimilarity(v1, v2) {
+    let dotProduct = 0;
+    let norm1 = 0;
+    let norm2 = 0;
+    for (let i = 0; i < v1.length; i++) {
+        dotProduct += v1[i] * v2[i];
+        norm1 += v1[i] * v1[i];
+        norm2 += v2[i] * v2[i];
+    }
+    return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
+}

package/dist/lib/ai/gpu-lock.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A simple Mutex to ensure only one heavy GPU task runs at a time.
+ * Prevents "Context Lost" errors when WebLLM and TensorFlow.js try to
+ * allocate VRAM simultaneously.
+ */
+export declare class GPUResourceLock {
+    private locked;
+    private queue;
+    /**
+     * Request access to the GPU. Returns a promise that resolves when access is granted.
+     * @param debugName - Name of the requester for logging
+     */
+    acquire(debugName: string): Promise<void>;
+    /**
+     * Release the GPU lock, allowing the next task in queue to proceed.
+     */
+    release(): void;
+}
+export declare const gpuLock: GPUResourceLock;

package/dist/lib/ai/gpu-lock.js

@@ -0,0 +1,43 @@
+/**
+ * A simple Mutex to ensure only one heavy GPU task runs at a time.
+ * Prevents "Context Lost" errors when WebLLM and TensorFlow.js try to
+ * allocate VRAM simultaneously.
+ */
+export class GPUResourceLock {
+    constructor() {
+        this.locked = false;
+        this.queue = [];
+    }
+    /**
+     * Request access to the GPU. Returns a promise that resolves when access is granted.
+     * @param debugName - Name of the requester for logging
+     */
+    async acquire(debugName) {
+        if (!this.locked) {
+            this.locked = true;
+            // console.log(`[GPU Lock] Acquired by ${debugName}`);
+            return Promise.resolve();
+        }
+        // console.log(`[GPU Lock] ${debugName} waiting for lock...`);
+        return new Promise((resolve) => {
+            this.queue.push(() => {
+                this.locked = true;
+                // console.log(`[GPU Lock] Acquired by ${debugName} (after wait)`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Release the GPU lock, allowing the next task in queue to proceed.
+     */
+    release() {
+        this.locked = false;
+        // console.log(`[GPU Lock] Released`);
+        const next = this.queue.shift();
+        if (next) {
+            next();
+        }
+    }
+}
+// Global Singleton
+export const gpuLock = new GPUResourceLock();

package/dist/lib/ai/llm.worker.d.ts

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

package/dist/lib/ai/llm.worker.js

@@ -0,0 +1,7 @@
+import { WebWorkerMLCEngineHandler } from "@mlc-ai/web-llm";
+// This is the worker script that will run the LLM in a background thread.
+// It prevents the UI from freezing during generation.
+const handler = new WebWorkerMLCEngineHandler();
+self.onmessage = (msg) => {
+    handler.onmessage(msg);
+};

package/dist/lib/ai/local-llm.d.ts

@@ -0,0 +1,30 @@
+import { AIChatMessage, AITool } from "./types";
+export declare class WebLLMService {
+    private engine;
+    private loading;
+    private currentModelId;
+    private initPromise;
+    private progressListeners;
+    private worker;
+    /**
+     * Connect to or Initialize the Engine via Web Worker
+     */
+    initialize(modelId: string, progressCallback?: (text: string) => void, config?: {
+        context_window?: number;
+    }): Promise<void>;
+    isInitialized(): boolean;
+    chat(messages: AIChatMessage[], onUpdate: (chunk: string) => void, options?: {
+        tools?: AITool[];
+        temperature?: number;
+        top_p?: number;
+        stop?: string[];
+    }): Promise<string>;
+    isLoading(): boolean;
+    getModelId(): string | null;
+    interrupt(): Promise<void>;
+    /**
+     * Completely unload the engine and terminate the worker to free memory.
+     */
+    unload(): Promise<void>;
+}
+export declare const localLlmService: WebLLMService;

package/dist/lib/ai/local-llm.js

@@ -0,0 +1,211 @@
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { CreateWebWorkerMLCEngine } from "@mlc-ai/web-llm";
+import { getModelConfig } from "./registry";
+import { gpuLock } from "./gpu-lock";
+export class WebLLMService {
+    constructor() {
+        this.engine = null;
+        this.loading = false;
+        this.currentModelId = null;
+        this.initPromise = null;
+        this.progressListeners = [];
+        this.worker = null;
+    }
+    /**
+     * Connect to or Initialize the Engine via Web Worker
+     */
+    async initialize(modelId, progressCallback, config = {}) {
+        if (this.engine && this.currentModelId === modelId) {
+            return;
+        }
+        // Check for Secure Context / Cache API (Required for WebLLM)
+        if (typeof window !== 'undefined' && !window.caches) {
+            throw new Error("Secure Context Required: The Cache API is missing. Please use HTTPS or 'localhost', or enable 'Insecure origins treated as secure' in chrome://flags.");
+        }
+        if (progressCallback) {
+            this.progressListeners.push(progressCallback);
+        }
+        // If initialization is in progress, return the existing promise
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.loading = true;
+        // Create a new initialization promise
+        this.initPromise = (async () => {
+            var _a, _b;
+            try {
+                console.log("[Meechi] Initializing via Dedicated Web Worker...");
+                // Ensure previous engine is unloaded to free GPU memory
+                if (this.engine) {
+                    try {
+                        console.log("[Meechi] Unloading previous engine...");
+                        await this.engine.unload();
+                        // Terminate old worker to fully free memory
+                        if (this.worker) {
+                            this.worker.terminate();
+                            this.worker = null;
+                        }
+                    }
+                    catch (e) {
+                        console.warn("[Meechi] Failed to clean unload:", e);
+                    }
+                    this.engine = null;
+                }
+                // Get Model Config
+                const modelConfig = getModelConfig(modelId);
+                // PERFORMANCE TUNING: Mobile Detection
+                // Mobile GPUs (iOS/Android) often crash with default 4096 context.
+                // We aggressively cap it to 2048 or lower to ensure stability and speed.
+                const isMobile = typeof navigator !== 'undefined' && /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
+                const defaultContext = (modelConfig === null || modelConfig === void 0 ? void 0 : modelConfig.context_window) || 4096;
+                // If mobile, cap at 2048 (or the requested config, if lower).
+                // If desktop, use the robust default.
+                let safeContext = config.context_window || defaultContext;
+                if (isMobile && safeContext > 2048) {
+                    console.log("[Meechi] Mobile detected. Capping context window to 2048 for stability.");
+                    safeContext = 2048;
+                }
+                // Create new Worker
+                this.worker = new Worker(new URL('./llm.worker.ts', import.meta.url), { type: 'module' });
+                this.engine = await CreateWebWorkerMLCEngine(this.worker, modelId, {
+                    initProgressCallback: (progress) => {
+                        this.progressListeners.forEach(cb => cb(progress.text));
+                    },
+                }, {
+                    context_window_size: safeContext,
+                });
+                this.currentModelId = modelId;
+            }
+            catch (error) {
+                console.error("Failed to initialize WebLLM:", error);
+                // FORCE RESET on error
+                if (this.engine) {
+                    try {
+                        await this.engine.unload();
+                    }
+                    catch (_c) { }
+                    this.engine = null;
+                }
+                if (this.worker) {
+                    this.worker.terminate();
+                    this.worker = null;
+                }
+                this.currentModelId = null;
+                // Check for GPU Context Lost
+                if (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("Context lost")) || ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes("valid external Instance"))) {
+                    console.warn("GPU Context Lost detected during init. Clearing state...");
+                }
+                throw error;
+            }
+            finally {
+                this.loading = false;
+                this.initPromise = null; // Clear promise so next attempt works
+                this.progressListeners = []; // Clear listeners
+            }
+        })();
+        return this.initPromise;
+    }
+    isInitialized() {
+        return !!this.engine;
+    }
+    async chat(messages, onUpdate, options = {}) {
+        var _a, e_1, _b, _c;
+        var _d, _e, _f;
+        if (!this.engine) {
+            throw new Error("Local Engine not initialized");
+        }
+        // ACQUIRE GPU LOCK
+        // This stops RAG from trying to embed while we are generating tokens
+        await gpuLock.acquire('Chat');
+        let fullResponse = "";
+        try {
+            const completion = await this.engine.chat.completions.create({
+                messages: messages,
+                stream: true,
+                temperature: (_d = options.temperature) !== null && _d !== void 0 ? _d : 0.7,
+                top_p: (_e = options.top_p) !== null && _e !== void 0 ? _e : 0.9,
+                stop: options.stop,
+                frequency_penalty: 0.1, // Slight penalty to prevent infinite loops "The user has asked..."
+            });
+            try {
+                for (var _g = true, completion_1 = __asyncValues(completion), completion_1_1; completion_1_1 = await completion_1.next(), _a = completion_1_1.done, !_a; _g = true) {
+                    _c = completion_1_1.value;
+                    _g = false;
+                    const chunk = _c;
+                    const delta = ((_f = chunk.choices[0]) === null || _f === void 0 ? void 0 : _f.delta.content) || "";
+                    if (delta) {
+                        fullResponse += delta;
+                        onUpdate(delta);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_g && !_a && (_b = completion_1.return)) await _b.call(completion_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        catch (e) {
+            console.error("WebLLM Chat Error:", e);
+            // Detect GPU Context Loss or Device Loss
+            const errMsg = e.message || "";
+            if (errMsg.includes("Context lost") || errMsg.includes("Device was lost") || errMsg.includes("Instance reference no longer exists") || errMsg.includes("dropped in popErrorScope") || errMsg.includes("already been disposed")) {
+                console.warn("GPU Crash detected. Resetting WebLLM engine state...");
+                this.engine = null;
+                this.currentModelId = null;
+                if (this.worker) {
+                    this.worker.terminate();
+                    this.worker = null;
+                }
+                // Propagate a specific error for the UI to handle (e.g., suggest reload)
+                throw new Error("GPU_CRASH");
+            }
+            throw e;
+        }
+        finally {
+            // RELEASE GPU LOCK
+            gpuLock.release();
+        }
+        return fullResponse;
+    }
+    isLoading() {
+        return this.loading;
+    }
+    getModelId() {
+        return this.currentModelId;
+    }
+    async interrupt() {
+        if (this.engine) {
+            await this.engine.interruptGenerate();
+        }
+    }
+    /**
+     * Completely unload the engine and terminate the worker to free memory.
+     */
+    async unload() {
+        if (this.engine) {
+            try {
+                console.log("[Meechi] Unloading engine explicitly...");
+                await this.engine.unload();
+            }
+            catch (e) {
+                console.warn("[Meechi] Error unloading engine:", e);
+            }
+            this.engine = null;
+        }
+        if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+        }
+        this.currentModelId = null;
+    }
+}
+export const localLlmService = new WebLLMService();

package/dist/lib/ai/manager.d.ts

@@ -0,0 +1,20 @@
+import { AIChatMessage, AITool, AICompletion, AIProvider } from "./types";
+export interface AIConfig {
+    activeProviderId: string;
+    providers: {
+        id: string;
+        apiKey?: string;
+        model?: string;
+    }[];
+    identity?: {
+        name: string;
+        tone: string;
+    };
+}
+export declare class AIManager {
+    private providers;
+    constructor();
+    registerProvider(provider: AIProvider): void;
+    chat(userMessage: string, systemContext: string, history: AIChatMessage[], config: AIConfig, tools?: AITool[]): Promise<AICompletion>;
+}
+export declare const aiManager: AIManager;

package/dist/lib/ai/manager.js

@@ -0,0 +1,51 @@
+import { SYSTEM_PROMPT } from "./prompts";
+import { GroqProvider } from "./providers/groq";
+import { GeminiProvider } from "./providers/gemini";
+export class AIManager {
+    constructor() {
+        this.providers = new Map();
+        // Register default providers
+        this.registerProvider(new GroqProvider());
+        this.registerProvider(new GeminiProvider());
+    }
+    registerProvider(provider) {
+        this.providers.set(provider.id, provider);
+    }
+    async chat(userMessage, systemContext, history, config, tools) {
+        // 1. Determine Primary Provider
+        const primaryId = config.activeProviderId || 'groq';
+        let providerConfig = config.providers.find(p => p.id === primaryId);
+        let provider = this.providers.get(primaryId);
+        // CHECK API KEY for Cloud Providers
+        if (primaryId === 'openai' && !(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey) && !process.env.OPENAI_API_KEY) {
+            console.warn("[Cloud] No OpenAI Key found.");
+            return {
+                content: "I am unable to connect to the cloud because no API Key is configured. Please check your settings or restart the Local AI.",
+                usage: { total_tokens: 0 }
+            };
+        }
+        if (!provider) {
+            console.warn(`Provider ${primaryId} not found. Falling back to Groq.`);
+            provider = this.providers.get('groq');
+        }
+        // 2. Construct Messages
+        // Inject Identity/Tone into System Prompt
+        // Inject Identity/Tone into System Prompt
+        // 2. Construct Messages
+        const systemPrompt = `
+${SYSTEM_PROMPT}
+
+Context:
+${systemContext}
+        `.trim();
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            ...history,
+            { role: 'user', content: userMessage }
+        ];
+        // 3. Attempt Chat
+        // We throw errors to let the client handle fallback (e.g. Local AI)
+        return await provider.chat((providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.model) || "", messages, tools, providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey);
+    }
+}
+export const aiManager = new AIManager();

package/dist/lib/ai/parsing.d.ts

@@ -0,0 +1,12 @@
+export interface ToolCall {
+    name: string;
+    args: any;
+    raw: string;
+    error?: string;
+}
+/**
+ * Parses tool calls from AI response text.
+ * Supports XML format: <function="name">args</function>
+ * Robust to common LLM formatting errors.
+ */
+export declare function parseToolCalls(content: string): ToolCall[];

package/dist/lib/ai/parsing.js

@@ -0,0 +1,56 @@
+/**
+ * Parses tool calls from AI response text.
+ * Supports XML format: <function="name">args</function>
+ * Robust to common LLM formatting errors.
+ */
+export function parseToolCalls(content) {
+    const tools = [];
+    // Regex for <function="name">{args}</function> or <function name='name'>{args}</function>
+    // Improved to be more permissive with whitespace and attributes
+    const toolRegex = /<function(?:=\s*["']?([^"'>]+)["']?|\s+name=["']?([^"'>]+)["']?)\s*>([\s\S]*?)<\/function>/gi;
+    let match;
+    while ((match = toolRegex.exec(content)) !== null) {
+        // match[1] or match[2] is the name
+        const name = (match[1] || match[2]).replace(/["']/g, "").trim();
+        const argsStr = match[3].trim();
+        try {
+            // Attempt 1: Direct JSON parse
+            const args = JSON.parse(argsStr);
+            tools.push({ name, args, raw: match[0] });
+        }
+        catch (e) {
+            // Attempt 2: Sanitize Common JSON Errors
+            try {
+                // 1. Handle Newlines in strings (LLMs often put literal newlines in JSON strings)
+                // 2. Handle Markdown code blocks if they wrapped the JSON inside the XML (rare but happens)
+                let cleaned = argsStr
+                    .replace(/^```json\s*/i, '')
+                    .replace(/\s*```$/, '');
+                // Sanitize newlines inside double quotes
+                cleaned = cleaned.replace(/"((?:[^"\\]|\\.)*)"/g, (m) => {
+                    return m.replace(/\n/g, "\\n").replace(/\r/g, "");
+                });
+                const args = JSON.parse(cleaned);
+                tools.push({ name, args, raw: match[0] });
+            }
+            catch (e2) {
+                // Attempt 3: Aggressive Fixes (Last resort)
+                try {
+                    let fixed = argsStr
+                        .replace(/'/g, '"') // Helper for single quotes
+                        .replace(/,\s*}/g, '}') // Trailing commas
+                        .replace(/([{,]\s*)([a-zA-Z0-9_]+)\s*:/g, '$1"$2":'); // Unquoted keys
+                    // Re-sanitize strings
+                    fixed = fixed.replace(/"((?:[^"\\]|\\.)*)"/g, (m) => m.replace(/\n/g, "\\n"));
+                    const args = JSON.parse(fixed);
+                    tools.push({ name, args, raw: match[0] });
+                }
+                catch (e3) {
+                    console.error(`Failed to parse args for tool ${name}`, argsStr);
+                    tools.push({ name, args: {}, error: "Invalid JSON arguments", raw: match[0] });
+                }
+            }
+        }
+    }
+    return tools;
+}

package/dist/lib/ai/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare const SYSTEM_PROMPT = "You are Meechi, an intelligent AI assistant living on the user's computer. You are helpful, harmless, and honest.";
+export declare const RESEARCH_SYSTEM_PROMPT = "You are a Research Assistant. Analyze the provided context and answer questions based on the data.";

package/dist/lib/ai/prompts.js

@@ -0,0 +1,2 @@
+export const SYSTEM_PROMPT = "You are Meechi, an intelligent AI assistant living on the user's computer. You are helpful, harmless, and honest.";
+export const RESEARCH_SYSTEM_PROMPT = "You are a Research Assistant. Analyze the provided context and answer questions based on the data.";

package/dist/lib/ai/providers/gemini.d.ts

@@ -0,0 +1,6 @@
+import { AIProvider, AIChatMessage, AITool, AICompletion } from "../types";
+export declare class GeminiProvider implements AIProvider {
+    id: string;
+    name: string;
+    chat(model: string, messages: AIChatMessage[], tools?: AITool[], apiKey?: string): Promise<AICompletion>;
+}