@ruvector/ruvllm 4.0.0 → 4.1.0

package/dist/esm/engine.js

@@ -0,0 +1,548 @@
+/**
+ * RuvLLM Engine - Main orchestrator for self-learning LLM
+ */
+import { getNativeModule, } from './native.js';
+/**
+ * Convert JS config to native config format
+ */
+function toNativeConfig(config) {
+    if (!config)
+        return undefined;
+    return {
+        embedding_dim: config.embeddingDim,
+        router_hidden_dim: config.routerHiddenDim,
+        hnsw_m: config.hnswM,
+        hnsw_ef_construction: config.hnswEfConstruction,
+        hnsw_ef_search: config.hnswEfSearch,
+        learning_enabled: config.learningEnabled,
+        quality_threshold: config.qualityThreshold,
+        ewc_lambda: config.ewcLambda,
+    };
+}
+/**
+ * Convert JS generation config to native format
+ */
+function toNativeGenConfig(config) {
+    if (!config)
+        return undefined;
+    // camelCase: napi-rs ignores snake_case keys on `#[napi(object)]` inputs.
+    return {
+        maxTokens: config.maxTokens,
+        temperature: config.temperature,
+        topP: config.topP,
+        topK: config.topK,
+        repetitionPenalty: config.repetitionPenalty,
+        stopSequences: config.stopSequences,
+        seed: config.seed,
+    };
+}
+function toGenerationResult(r) {
+    return {
+        text: r.text,
+        promptTokens: r.promptTokens,
+        completionTokens: r.completionTokens,
+        finishReason: r.finishReason,
+    };
+}
+function toModelInfo(i) {
+    return {
+        name: i.name,
+        architecture: i.architecture,
+        numParameters: i.numParameters,
+        vocabSize: i.vocabSize,
+        hiddenSize: i.hiddenSize,
+        numLayers: i.numLayers,
+        maxContextLength: i.maxContextLength,
+        quantization: i.quantization ?? null,
+        memoryUsageBytes: i.memoryUsageBytes,
+        chatTemplate: i.chatTemplate ?? null,
+    };
+}
+const warned = new Set();
+/** Warn once per process (or throw when `strict`). */
+function notice(code, message, strict) {
+    if (strict)
+        throw codedError(code, message);
+    if (warned.has(code))
+        return;
+    warned.add(code);
+    const g = globalThis;
+    if (typeof g.process?.emitWarning === 'function')
+        g.process.emitWarning(message, { code });
+    else
+        g.console?.warn?.(`${code}: ${message}`);
+}
+/** An Error whose message starts with, and whose `code` is, `code`. */
+function codedError(code, message) {
+    const err = new Error(`${code}: ${message}`);
+    err.code = code;
+    return err;
+}
+/**
+ * Call into the native engine, giving its errors the same `code` as the
+ * wrapper's own: native messages start with `RUVLLM_<CODE>:`, but napi-rs
+ * sets `code` to a generic status such as `GenericFailure`.
+ */
+function callNative(f) {
+    try {
+        return f();
+    }
+    catch (e) {
+        const match = /^(RUVLLM_[A-Z_]+):/.exec(e instanceof Error ? e.message : '');
+        if (match)
+            e.code = match[1];
+        throw e;
+    }
+}
+function platformKey() {
+    const p = globalThis.process;
+    return `${p?.platform ?? 'unknown'}-${p?.arch ?? 'unknown'}`;
+}
+function envAllowsPlaceholder() {
+    const p = globalThis.process;
+    return p?.env?.RUVLLM_ALLOW_MOCK === '1';
+}
+/** Returned by generate()/query() only with `allowPlaceholder` / `RUVLLM_ALLOW_MOCK=1`. */
+export const PLACEHOLDER_TEXT = '[RuvLLM placeholder: no language model is loaded; this text is not model output]';
+/**
+ * RuvLLM - Self-learning LLM orchestrator
+ *
+ * Combines SONA adaptive learning with HNSW memory, FastGRNN routing, and
+ * GGUF inference through the native candle backend.
+ *
+ * Text comes only from a model loaded with `loadModel()` (or the `modelPath`
+ * option). Without one, `generate()`, `query()`, `chat()` and
+ * `generateDetailed()` throw `RUVLLM_NO_LANGUAGE_MODEL`.
+ *
+ * @example
+ * ```typescript
+ * import { RuvLLM } from '@ruvector/ruvllm';
+ *
+ * const llm = new RuvLLM();
+ * llm.loadModel('./qwen2.5-0.5b-instruct-q4_k_m.gguf');
+ *
+ * const out = llm.chat([{ role: 'user', content: 'What is machine learning?' }], {
+ *   maxTokens: 128,
+ * });
+ * console.log(out.text, out.finishReason, out.completionTokens);
+ *
+ * // Routed query, answered by the loaded model
+ * const response = llm.query('What is machine learning?');
+ * llm.feedback({ requestId: response.requestId, rating: 5 });
+ * ```
+ */
+export class RuvLLM {
+    /**
+     * Create a new RuvLLM instance
+     */
+    constructor(config) {
+        this.native = null;
+        this.nativeVersion = null;
+        // Fallback state for when native module is not available
+        this.fallbackState = {
+            memory: new Map(),
+            nextId: 1,
+            queryCount: 0,
+        };
+        this.config = config ?? {};
+        this.allowPlaceholder = this.config.allowPlaceholder === true || envAllowsPlaceholder();
+        const extra = this.config;
+        if (extra.backend !== undefined) {
+            notice('RUVLLM_UNSUPPORTED_OPTION', '`backend` is not supported by @ruvector/ruvllm and is ignored: models loaded with ' +
+                'loadModel() run on the built-in candle backend.', this.config.strict);
+        }
+        const mod = getNativeModule();
+        if (mod) {
+            try {
+                this.native = new mod.RuvLLMEngine(toNativeConfig(config));
+                this.nativeVersion = mod.version();
+            }
+            catch {
+                // Silently fall back to JS implementation
+            }
+        }
+        if (this.config.modelPath !== undefined) {
+            this.loadModel(this.config.modelPath, this.config.modelOptions);
+        }
+    }
+    /**
+     * Whether the native binary can load and run a language model. False
+     * without a native binary, for binaries that predate `loadModel` (the 2.0.x
+     * `@ruvector/ruvllm-<platform>` packages), and for binaries built without
+     * the `candle` inference backend.
+     */
+    supportsModelLoading() {
+        const native = this.native;
+        if (typeof native?.loadModel !== 'function')
+            return false;
+        // Builds that predate this probe all had the backend (they were local
+        // `npm run build:native` builds, which enable `candle`).
+        return typeof native.supportsModelLoading === 'function' ? native.supportsModelLoading() : true;
+    }
+    /** Error for a binary that has `loadModel` but no inference backend. */
+    noBackendError() {
+        return codedError('RUVLLM_NO_INFERENCE_BACKEND', `the installed native binary (version ${this.nativeVersion ?? 'unknown'}) was built ` +
+            'without the `candle` inference backend and cannot load models. Rebuild it with ' +
+            '`npm run build:native` (which enables `candle`) and set RUVLLM_NATIVE_PATH to it, ' +
+            'or use the ruvllm CLI (`ruvllm serve <model>`).');
+    }
+    /**
+     * Load a GGUF model (or a directory holding one) for `generate()`,
+     * `chat()` and `query()`. Supported GGUF architectures: llama, mistral,
+     * qwen2, qwen3; others fail with an error naming the architecture. The
+     * tokenizer comes from a `tokenizer.json` beside the file, else from the
+     * GGUF itself. Replaces any loaded model; if loading fails, no model is
+     * loaded. Synchronous: blocks the event loop while the weights load.
+     *
+     * @throws `RUVLLM_NATIVE_UNAVAILABLE` without a native binary,
+     *   `RUVLLM_NATIVE_TOO_OLD` when the binary predates model loading,
+     *   `RUVLLM_NO_INFERENCE_BACKEND` when it was built without `candle`,
+     *   `RUVLLM_MODEL_NOT_FOUND` / `RUVLLM_MODEL_LOAD_FAILED` from the backend.
+     */
+    loadModel(path, options) {
+        if (typeof path !== 'string' || path.length === 0) {
+            throw new TypeError('loadModel: path must be a non-empty string');
+        }
+        if (!this.native) {
+            throw codedError('RUVLLM_NATIVE_UNAVAILABLE', `no native RuvLLM binary could be loaded for ${platformKey()}, so models cannot be ` +
+                'loaded. Install the matching @ruvector/ruvllm-<platform> package, or build one ' +
+                '(`npm run build:native`) and set RUVLLM_NATIVE_PATH to it.');
+        }
+        if (typeof this.native.loadModel !== 'function') {
+            throw codedError('RUVLLM_NATIVE_TOO_OLD', `the installed native binary (version ${this.nativeVersion ?? 'unknown'}) cannot load ` +
+                'models: it predates loadModel(). The @ruvector/ruvllm-<platform> 2.0.x packages are ' +
+                'such builds. Install the 3.x platform package, or build the binary from source ' +
+                '(`npm run build:native`, which enables the `candle` feature) and set ' +
+                'RUVLLM_NATIVE_PATH to it, or use the ruvllm CLI (`ruvllm serve <model>`).');
+        }
+        if (!this.supportsModelLoading())
+            throw this.noBackendError();
+        const native = this.native;
+        return toModelInfo(callNative(() => native.loadModel(path, options)));
+    }
+    /**
+     * Unload the language model and free its memory
+     */
+    unloadModel() {
+        this.native?.unloadModel?.();
+    }
+    /**
+     * Whether a language model is loaded
+     */
+    isModelLoaded() {
+        return this.native?.isModelLoaded?.() ?? false;
+    }
+    /**
+     * The loaded language model, or null
+     */
+    modelInfo() {
+        const info = this.native?.modelInfo?.();
+        return info ? toModelInfo(info) : null;
+    }
+    /**
+     * Route `text`, then answer it with the loaded model (as one user message
+     * under the model's chat template).
+     *
+     * @throws `RUVLLM_NO_LANGUAGE_MODEL` when no model is loaded, unless
+     *   `allowPlaceholder` is set (then `text` is `PLACEHOLDER_TEXT`).
+     */
+    query(text, config) {
+        if (!this.isModelLoaded()) {
+            const placeholder = this.placeholderOrThrow();
+            this.fallbackState.queryCount++;
+            const route = this.route(text);
+            return {
+                text: placeholder,
+                confidence: route.confidence,
+                model: route.model,
+                contextSize: route.contextSize,
+                latencyMs: 0,
+                requestId: `placeholder-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            };
+        }
+        const native = this.native;
+        const result = callNative(() => native.query(text, toNativeGenConfig(config)));
+        return {
+            text: result.text,
+            confidence: result.confidence,
+            model: result.model,
+            contextSize: result.contextSize,
+            latencyMs: result.latencyMs,
+            requestId: result.requestId,
+            promptTokens: result.promptTokens,
+            completionTokens: result.completionTokens,
+            finishReason: result.finishReason,
+        };
+    }
+    /**
+     * Continue `prompt` verbatim with the loaded model (no chat template; use
+     * `chat()` for instruction-tuned models). Returns the generated text.
+     *
+     * @throws `RUVLLM_NO_LANGUAGE_MODEL` when no model is loaded, unless
+     *   `allowPlaceholder` is set (then it returns `PLACEHOLDER_TEXT`).
+     */
+    generate(prompt, config) {
+        if (!this.isModelLoaded())
+            return this.placeholderOrThrow();
+        return this.generateDetailed(prompt, config).text;
+    }
+    /**
+     * Like `generate()`, with token counts (from the model's tokenizer) and
+     * the finish reason. Always throws `RUVLLM_NO_LANGUAGE_MODEL` without a
+     * loaded model.
+     */
+    generateDetailed(prompt, config) {
+        const native = this.requireModel();
+        return toGenerationResult(callNative(() => native.generate(prompt, toNativeGenConfig(config))));
+    }
+    /**
+     * Run the loaded model on a conversation, formatted with the model's chat
+     * template (ChatML for Qwen, Llama 3 / Mistral formats for those models).
+     * Always throws `RUVLLM_NO_LANGUAGE_MODEL` without a loaded model.
+     */
+    chat(messages, config) {
+        const native = this.requireModel();
+        return toGenerationResult(callNative(() => native.chat(messages, toNativeGenConfig(config))));
+    }
+    requireModel() {
+        if (!this.isModelLoaded())
+            throw this.noModelError();
+        return this.native;
+    }
+    noModelError() {
+        let fix;
+        if (!this.native) {
+            fix =
+                `no native RuvLLM binary is available for ${platformKey()}, so no model can be loaded ` +
+                    '(see RUVLLM_NATIVE_UNAVAILABLE in the README)';
+        }
+        else if (typeof this.native.loadModel !== 'function') {
+            fix =
+                `the installed native binary (version ${this.nativeVersion ?? 'unknown'}) cannot load ` +
+                    'models (see RUVLLM_NATIVE_TOO_OLD in the README)';
+        }
+        else if (!this.supportsModelLoading()) {
+            fix =
+                `the installed native binary (version ${this.nativeVersion ?? 'unknown'}) was built ` +
+                    'without the candle inference backend, so it cannot load models (see ' +
+                    'RUVLLM_NO_INFERENCE_BACKEND in the README)';
+        }
+        else {
+            fix = 'call loadModel(<path to a GGUF file>) first';
+        }
+        return codedError('RUVLLM_NO_LANGUAGE_MODEL', `no language model is loaded, so there is no model output to return: ${fix}. Routing, ` +
+            'memory and embeddings work without a model. For an HTTP server use the ruvllm CLI ' +
+            '(`ruvllm serve <model>`).');
+    }
+    /** Throw `RUVLLM_NO_LANGUAGE_MODEL`, or return the labelled placeholder when opted in. */
+    placeholderOrThrow() {
+        if (!this.allowPlaceholder)
+            throw this.noModelError();
+        notice('RUVLLM_PLACEHOLDER_TEXT', 'no language model is loaded: generate()/query() are returning a labelled placeholder, ' +
+            'not model output, because allowPlaceholder (or RUVLLM_ALLOW_MOCK=1) is set.', false);
+        return PLACEHOLDER_TEXT;
+    }
+    /**
+     * Get routing decision for a query
+     */
+    route(text) {
+        if (this.native) {
+            const result = this.native.route(text);
+            return {
+                model: result.model,
+                contextSize: result.contextSize ?? result.context_size,
+                temperature: result.temperature,
+                topP: result.topP ?? result.top_p,
+                confidence: result.confidence,
+            };
+        }
+        // Fallback
+        return {
+            model: 'M700',
+            contextSize: 512,
+            temperature: 0.7,
+            topP: 0.9,
+            confidence: 0.5,
+        };
+    }
+    /**
+     * Search memory for similar content
+     */
+    searchMemory(text, k = 10) {
+        if (this.native) {
+            const results = this.native.searchMemory(text, k);
+            return results.map(r => {
+                // The native side reports `distance` (smaller is closer). MemoryResult
+                // documents `score` as a similarity, so convert rather than passing a
+                // distance through under a similarity's name. Older builds that already
+                // emit `score` are used as-is.
+                const anyR = r;
+                const score = typeof anyR.score === 'number'
+                    ? anyR.score
+                    : typeof anyR.distance === 'number'
+                        ? 1 / (1 + Math.max(0, anyR.distance))
+                        : 0;
+                return {
+                    id: r.id,
+                    score,
+                    content: r.content,
+                    metadata: JSON.parse(r.metadata || '{}'),
+                };
+            });
+        }
+        // Fallback - simple search
+        return Array.from(this.fallbackState.memory.entries())
+            .slice(0, k)
+            .map(([id, data]) => ({
+            id,
+            score: 0.5,
+            content: data.content,
+            metadata: data.metadata,
+        }));
+    }
+    /**
+     * Add content to memory
+     */
+    addMemory(content, metadata) {
+        if (this.native) {
+            return this.native.addMemory(content, metadata ? JSON.stringify(metadata) : undefined);
+        }
+        // Fallback
+        const id = this.fallbackState.nextId++;
+        this.fallbackState.memory.set(id, {
+            content,
+            embedding: this.embed(content),
+            metadata: metadata ?? {},
+        });
+        return id;
+    }
+    /**
+     * Provide feedback for learning
+     */
+    feedback(fb) {
+        if (this.native) {
+            return this.native.feedback(fb.requestId, fb.rating, fb.correction);
+        }
+        return false;
+    }
+    /**
+     * Get engine statistics
+     */
+    stats() {
+        if (this.native) {
+            const s = this.native.stats();
+            // Map native stats (snake_case) to TypeScript interface (camelCase)
+            // Handle both old and new field names for backward compatibility
+            return {
+                totalQueries: s.totalQueries ?? s.total_queries ?? 0,
+                memoryNodes: s.memoryNodes ?? s.memory_nodes ?? 0,
+                patternsLearned: s.trainingSteps ??
+                    s.patterns_learned ??
+                    s.training_steps ??
+                    0,
+                avgLatencyMs: s.avgLatencyMs ?? s.avg_latency_ms ?? 0,
+                cacheHitRate: s.cacheHitRate ?? s.cache_hit_rate ?? 0,
+                routerAccuracy: s.routerAccuracy ?? s.router_accuracy ?? 0.5,
+            };
+        }
+        // Fallback
+        return {
+            totalQueries: this.fallbackState.queryCount,
+            memoryNodes: this.fallbackState.memory.size,
+            patternsLearned: 0,
+            avgLatencyMs: 1.0,
+            cacheHitRate: 0.0,
+            routerAccuracy: 0.5,
+        };
+    }
+    /**
+     * Force router learning cycle
+     */
+    forceLearn() {
+        if (this.native) {
+            return this.native.forceLearn();
+        }
+        return 'Learning not available in fallback mode';
+    }
+    /**
+     * Get embedding for text
+     */
+    embed(text) {
+        if (this.native) {
+            return this.native.embed(text);
+        }
+        // Fallback - simple hash-based embedding
+        const dim = this.config.embeddingDim ?? 768;
+        const embedding = new Array(dim).fill(0);
+        for (let i = 0; i < text.length; i++) {
+            const idx = (text.charCodeAt(i) * (i + 1)) % dim;
+            embedding[idx] += 0.1;
+        }
+        // Normalize
+        const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0)) || 1;
+        return embedding.map(x => x / norm);
+    }
+    /**
+     * Compute similarity between two texts
+     */
+    similarity(text1, text2) {
+        if (this.native) {
+            // f32 accumulation can land just outside the mathematical range — an
+            // identical pair measures 1.0000001 — which turns Math.acos(sim) into
+            // NaN downstream. Cosine similarity is defined on [-1, 1], so clamp.
+            const raw = this.native.similarity(text1, text2);
+            return Math.min(1, Math.max(-1, raw));
+        }
+        // Fallback - cosine similarity
+        const emb1 = this.embed(text1);
+        const emb2 = this.embed(text2);
+        let dot = 0;
+        let norm1 = 0;
+        let norm2 = 0;
+        for (let i = 0; i < emb1.length; i++) {
+            dot += emb1[i] * emb2[i];
+            norm1 += emb1[i] * emb1[i];
+            norm2 += emb2[i] * emb2[i];
+        }
+        const denom = Math.sqrt(norm1) * Math.sqrt(norm2);
+        const similarity = denom > 0 ? dot / denom : 0;
+        // Clamp to [0, 1] to handle floating point errors
+        return Math.max(0, Math.min(1, similarity));
+    }
+    /**
+     * Check if SIMD is available
+     */
+    hasSimd() {
+        if (this.native) {
+            return this.native.hasSimd();
+        }
+        return false;
+    }
+    /**
+     * Get SIMD capabilities
+     */
+    simdCapabilities() {
+        if (this.native) {
+            return this.native.simdCapabilities();
+        }
+        return ['Scalar (fallback)'];
+    }
+    /**
+     * Batch query multiple prompts
+     */
+    batchQuery(request) {
+        const start = Date.now();
+        const responses = request.queries.map(q => this.query(q, request.config));
+        return {
+            responses,
+            totalLatencyMs: Date.now() - start,
+        };
+    }
+    /**
+     * Check if native module is loaded
+     */
+    isNativeLoaded() {
+        return this.native !== null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../src/engine.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RuvLLM Engine - Main orchestrator for self-learning LLM\n */\n\nimport {\n  RuvLLMConfig,\n  GenerationConfig,\n  QueryResponse,\n  RoutingDecision,\n  MemoryResult,\n  MemoryId,\n  RuvLLMStats,\n  Feedback,\n  Embedding,\n  BatchQueryRequest,\n  BatchQueryResponse,\n  ChatMessage,\n  FinishReason,\n  GenerationResult,\n  LoadModelOptions,\n  LoadedModelInfo,\n} from './types';\n\nimport {\n  getNativeModule,\n  NativeEngine,\n  NativeConfig,\n  NativeGenConfig,\n  NativeGenerationResult,\n  NativeModelInfo,\n} from './native';\n\n/**\n * Convert JS config to native config format\n */\nfunction toNativeConfig(config?: RuvLLMConfig): NativeConfig | undefined {\n  if (!config) return undefined;\n\n  return {\n    embedding_dim: config.embeddingDim,\n    router_hidden_dim: config.routerHiddenDim,\n    hnsw_m: config.hnswM,\n    hnsw_ef_construction: config.hnswEfConstruction,\n    hnsw_ef_search: config.hnswEfSearch,\n    learning_enabled: config.learningEnabled,\n    quality_threshold: config.qualityThreshold,\n    ewc_lambda: config.ewcLambda,\n  };\n}\n\n/**\n * Convert JS generation config to native format\n */\nfunction toNativeGenConfig(config?: GenerationConfig): NativeGenConfig | undefined {\n  if (!config) return undefined;\n\n  // camelCase: napi-rs ignores snake_case keys on `#[napi(object)]` inputs.\n  return {\n    maxTokens: config.maxTokens,\n    temperature: config.temperature,\n    topP: config.topP,\n    topK: config.topK,\n    repetitionPenalty: config.repetitionPenalty,\n    stopSequences: config.stopSequences,\n    seed: config.seed,\n  };\n}\n\nfunction toGenerationResult(r: NativeGenerationResult): GenerationResult {\n  return {\n    text: r.text,\n    promptTokens: r.promptTokens,\n    completionTokens: r.completionTokens,\n    finishReason: r.finishReason as FinishReason,\n  };\n}\n\nfunction toModelInfo(i: NativeModelInfo): LoadedModelInfo {\n  return {\n    name: i.name,\n    architecture: i.architecture,\n    numParameters: i.numParameters,\n    vocabSize: i.vocabSize,\n    hiddenSize: i.hiddenSize,\n    numLayers: i.numLayers,\n    maxContextLength: i.maxContextLength,\n    quantization: i.quantization ?? null,\n    memoryUsageBytes: i.memoryUsageBytes,\n    chatTemplate: i.chatTemplate ?? null,\n  };\n}\n\nconst warned = new Set<string>();\n\n/** Warn once per process (or throw when `strict`). */\nfunction notice(code: string, message: string, strict: boolean | undefined): void {\n  if (strict) throw codedError(code, message);\n  if (warned.has(code)) return;\n  warned.add(code);\n  const g = globalThis as unknown as {\n    process?: { emitWarning?: (m: string, o?: { code?: string }) => void };\n    console?: { warn?: (m: string) => void };\n  };\n  if (typeof g.process?.emitWarning === 'function') g.process.emitWarning(message, { code });\n  else g.console?.warn?.(`${code}: ${message}`);\n}\n\n/** An Error whose message starts with, and whose `code` is, `code`. */\nfunction codedError(code: string, message: string): Error & { code: string } {\n  const err = new Error(`${code}: ${message}`) as Error & { code: string };\n  err.code = code;\n  return err;\n}\n\n/**\n * Call into the native engine, giving its errors the same `code` as the\n * wrapper's own: native messages start with `RUVLLM_<CODE>:`, but napi-rs\n * sets `code` to a generic status such as `GenericFailure`.\n */\nfunction callNative<T>(f: () => T): T {\n  try {\n    return f();\n  } catch (e) {\n    const match = /^(RUVLLM_[A-Z_]+):/.exec(e instanceof Error ? e.message : '');\n    if (match) (e as { code?: string }).code = match[1];\n    throw e;\n  }\n}\n\nfunction platformKey(): string {\n  const p = (globalThis as { process?: { platform?: string; arch?: string } }).process;\n  return `${p?.platform ?? 'unknown'}-${p?.arch ?? 'unknown'}`;\n}\n\nfunction envAllowsPlaceholder(): boolean {\n  const p = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process;\n  return p?.env?.RUVLLM_ALLOW_MOCK === '1';\n}\n\n/** Returned by generate()/query() only with `allowPlaceholder` / `RUVLLM_ALLOW_MOCK=1`. */\nexport const PLACEHOLDER_TEXT =\n  '[RuvLLM placeholder: no language model is loaded; this text is not model output]';\n\n/**\n * RuvLLM - Self-learning LLM orchestrator\n *\n * Combines SONA adaptive learning with HNSW memory, FastGRNN routing, and\n * GGUF inference through the native candle backend.\n *\n * Text comes only from a model loaded with `loadModel()` (or the `modelPath`\n * option). Without one, `generate()`, `query()`, `chat()` and\n * `generateDetailed()` throw `RUVLLM_NO_LANGUAGE_MODEL`.\n *\n * @example\n * ```typescript\n * import { RuvLLM } from '@ruvector/ruvllm';\n *\n * const llm = new RuvLLM();\n * llm.loadModel('./qwen2.5-0.5b-instruct-q4_k_m.gguf');\n *\n * const out = llm.chat([{ role: 'user', content: 'What is machine learning?' }], {\n *   maxTokens: 128,\n * });\n * console.log(out.text, out.finishReason, out.completionTokens);\n *\n * // Routed query, answered by the loaded model\n * const response = llm.query('What is machine learning?');\n * llm.feedback({ requestId: response.requestId, rating: 5 });\n * ```\n */\nexport class RuvLLM {\n  private native: NativeEngine | null = null;\n  private nativeVersion: string | null = null;\n  private config: RuvLLMConfig;\n  private allowPlaceholder: boolean;\n\n  // Fallback state for when native module is not available\n  private fallbackState = {\n    memory: new Map<number, { content: string; embedding: number[]; metadata: Record<string, unknown> }>(),\n    nextId: 1,\n    queryCount: 0,\n  };\n\n  /**\n   * Create a new RuvLLM instance\n   */\n  constructor(config?: RuvLLMConfig) {\n    this.config = config ?? {};\n    this.allowPlaceholder = this.config.allowPlaceholder === true || envAllowsPlaceholder();\n    const extra = this.config as Record<string, unknown>;\n    if (extra.backend !== undefined) {\n      notice(\n        'RUVLLM_UNSUPPORTED_OPTION',\n        '`backend` is not supported by @ruvector/ruvllm and is ignored: models loaded with ' +\n          'loadModel() run on the built-in candle backend.',\n        this.config.strict,\n      );\n    }\n\n    const mod = getNativeModule();\n    if (mod) {\n      try {\n        this.native = new mod.RuvLLMEngine(toNativeConfig(config));\n        this.nativeVersion = mod.version();\n      } catch {\n        // Silently fall back to JS implementation\n      }\n    }\n\n    if (this.config.modelPath !== undefined) {\n      this.loadModel(this.config.modelPath, this.config.modelOptions);\n    }\n  }\n\n  /**\n   * Whether the native binary can load and run a language model. False\n   * without a native binary, for binaries that predate `loadModel` (the 2.0.x\n   * `@ruvector/ruvllm-<platform>` packages), and for binaries built without\n   * the `candle` inference backend.\n   */\n  supportsModelLoading(): boolean {\n    const native = this.native;\n    if (typeof native?.loadModel !== 'function') return false;\n    // Builds that predate this probe all had the backend (they were local\n    // `npm run build:native` builds, which enable `candle`).\n    return typeof native.supportsModelLoading === 'function' ? native.supportsModelLoading() : true;\n  }\n\n  /** Error for a binary that has `loadModel` but no inference backend. */\n  private noBackendError(): Error {\n    return codedError(\n      'RUVLLM_NO_INFERENCE_BACKEND',\n      `the installed native binary (version ${this.nativeVersion ?? 'unknown'}) was built ` +\n        'without the `candle` inference backend and cannot load models. Rebuild it with ' +\n        '`npm run build:native` (which enables `candle`) and set RUVLLM_NATIVE_PATH to it, ' +\n        'or use the ruvllm CLI (`ruvllm serve <model>`).',\n    );\n  }\n\n  /**\n   * Load a GGUF model (or a directory holding one) for `generate()`,\n   * `chat()` and `query()`. Supported GGUF architectures: llama, mistral,\n   * qwen2, qwen3; others fail with an error naming the architecture. The\n   * tokenizer comes from a `tokenizer.json` beside the file, else from the\n   * GGUF itself. Replaces any loaded model; if loading fails, no model is\n   * loaded. Synchronous: blocks the event loop while the weights load.\n   *\n   * @throws `RUVLLM_NATIVE_UNAVAILABLE` without a native binary,\n   *   `RUVLLM_NATIVE_TOO_OLD` when the binary predates model loading,\n   *   `RUVLLM_NO_INFERENCE_BACKEND` when it was built without `candle`,\n   *   `RUVLLM_MODEL_NOT_FOUND` / `RUVLLM_MODEL_LOAD_FAILED` from the backend.\n   */\n  loadModel(path: string, options?: LoadModelOptions): LoadedModelInfo {\n    if (typeof path !== 'string' || path.length === 0) {\n      throw new TypeError('loadModel: path must be a non-empty string');\n    }\n    if (!this.native) {\n      throw codedError(\n        'RUVLLM_NATIVE_UNAVAILABLE',\n        `no native RuvLLM binary could be loaded for ${platformKey()}, so models cannot be ` +\n          'loaded. Install the matching @ruvector/ruvllm-<platform> package, or build one ' +\n          '(`npm run build:native`) and set RUVLLM_NATIVE_PATH to it.',\n      );\n    }\n    if (typeof this.native.loadModel !== 'function') {\n      throw codedError(\n        'RUVLLM_NATIVE_TOO_OLD',\n        `the installed native binary (version ${this.nativeVersion ?? 'unknown'}) cannot load ` +\n          'models: it predates loadModel(). The @ruvector/ruvllm-<platform> 2.0.x packages are ' +\n          'such builds. Install the 3.x platform package, or build the binary from source ' +\n          '(`npm run build:native`, which enables the `candle` feature) and set ' +\n          'RUVLLM_NATIVE_PATH to it, or use the ruvllm CLI (`ruvllm serve <model>`).',\n      );\n    }\n    if (!this.supportsModelLoading()) throw this.noBackendError();\n    const native = this.native;\n    return toModelInfo(callNative(() => native.loadModel!(path, options)));\n  }\n\n  /**\n   * Unload the language model and free its memory\n   */\n  unloadModel(): void {\n    this.native?.unloadModel?.();\n  }\n\n  /**\n   * Whether a language model is loaded\n   */\n  isModelLoaded(): boolean {\n    return this.native?.isModelLoaded?.() ?? false;\n  }\n\n  /**\n   * The loaded language model, or null\n   */\n  modelInfo(): LoadedModelInfo | null {\n    const info = this.native?.modelInfo?.();\n    return info ? toModelInfo(info) : null;\n  }\n\n  /**\n   * Route `text`, then answer it with the loaded model (as one user message\n   * under the model's chat template).\n   *\n   * @throws `RUVLLM_NO_LANGUAGE_MODEL` when no model is loaded, unless\n   *   `allowPlaceholder` is set (then `text` is `PLACEHOLDER_TEXT`).\n   */\n  query(text: string, config?: GenerationConfig): QueryResponse {\n    if (!this.isModelLoaded()) {\n      const placeholder = this.placeholderOrThrow();\n      this.fallbackState.queryCount++;\n      const route = this.route(text);\n      return {\n        text: placeholder,\n        confidence: route.confidence,\n        model: route.model,\n        contextSize: route.contextSize,\n        latencyMs: 0,\n        requestId: `placeholder-${Date.now()}-${Math.random().toString(36).slice(2)}`,\n      };\n    }\n\n    const native = this.native!;\n    const result = callNative(() => native.query(text, toNativeGenConfig(config)));\n    return {\n      text: result.text,\n      confidence: result.confidence,\n      model: result.model,\n      contextSize: result.contextSize,\n      latencyMs: result.latencyMs,\n      requestId: result.requestId,\n      promptTokens: result.promptTokens,\n      completionTokens: result.completionTokens,\n      finishReason: result.finishReason as FinishReason | undefined,\n    };\n  }\n\n  /**\n   * Continue `prompt` verbatim with the loaded model (no chat template; use\n   * `chat()` for instruction-tuned models). Returns the generated text.\n   *\n   * @throws `RUVLLM_NO_LANGUAGE_MODEL` when no model is loaded, unless\n   *   `allowPlaceholder` is set (then it returns `PLACEHOLDER_TEXT`).\n   */\n  generate(prompt: string, config?: GenerationConfig): string {\n    if (!this.isModelLoaded()) return this.placeholderOrThrow();\n    return this.generateDetailed(prompt, config).text;\n  }\n\n  /**\n   * Like `generate()`, with token counts (from the model's tokenizer) and\n   * the finish reason. Always throws `RUVLLM_NO_LANGUAGE_MODEL` without a\n   * loaded model.\n   */\n  generateDetailed(prompt: string, config?: GenerationConfig): GenerationResult {\n    const native = this.requireModel();\n    return toGenerationResult(\n      callNative(() => native.generate(prompt, toNativeGenConfig(config))) as NativeGenerationResult,\n    );\n  }\n\n  /**\n   * Run the loaded model on a conversation, formatted with the model's chat\n   * template (ChatML for Qwen, Llama 3 / Mistral formats for those models).\n   * Always throws `RUVLLM_NO_LANGUAGE_MODEL` without a loaded model.\n   */\n  chat(messages: ChatMessage[], config?: GenerationConfig): GenerationResult {\n    const native = this.requireModel();\n    return toGenerationResult(callNative(() => native.chat!(messages, toNativeGenConfig(config))));\n  }\n\n  private requireModel(): NativeEngine {\n    if (!this.isModelLoaded()) throw this.noModelError();\n    return this.native!;\n  }\n\n  private noModelError(): Error {\n    let fix: string;\n    if (!this.native) {\n      fix =\n        `no native RuvLLM binary is available for ${platformKey()}, so no model can be loaded ` +\n        '(see RUVLLM_NATIVE_UNAVAILABLE in the README)';\n    } else if (typeof this.native.loadModel !== 'function') {\n      fix =\n        `the installed native binary (version ${this.nativeVersion ?? 'unknown'}) cannot load ` +\n        'models (see RUVLLM_NATIVE_TOO_OLD in the README)';\n    } else if (!this.supportsModelLoading()) {\n      fix =\n        `the installed native binary (version ${this.nativeVersion ?? 'unknown'}) was built ` +\n        'without the candle inference backend, so it cannot load models (see ' +\n        'RUVLLM_NO_INFERENCE_BACKEND in the README)';\n    } else {\n      fix = 'call loadModel(<path to a GGUF file>) first';\n    }\n    return codedError(\n      'RUVLLM_NO_LANGUAGE_MODEL',\n      `no language model is loaded, so there is no model output to return: ${fix}. Routing, ` +\n        'memory and embeddings work without a model. For an HTTP server use the ruvllm CLI ' +\n        '(`ruvllm serve <model>`).',\n    );\n  }\n\n  /** Throw `RUVLLM_NO_LANGUAGE_MODEL`, or return the labelled placeholder when opted in. */\n  private placeholderOrThrow(): string {\n    if (!this.allowPlaceholder) throw this.noModelError();\n    notice(\n      'RUVLLM_PLACEHOLDER_TEXT',\n      'no language model is loaded: generate()/query() are returning a labelled placeholder, ' +\n        'not model output, because allowPlaceholder (or RUVLLM_ALLOW_MOCK=1) is set.',\n      false,\n    );\n    return PLACEHOLDER_TEXT;\n  }\n\n  /**\n   * Get routing decision for a query\n   */\n  route(text: string): RoutingDecision {\n    if (this.native) {\n      const result = this.native.route(text);\n      return {\n        model: result.model as any,\n        contextSize: result.contextSize ?? result.context_size,\n        temperature: result.temperature,\n        topP: result.topP ?? result.top_p,\n        confidence: result.confidence,\n      };\n    }\n\n    // Fallback\n    return {\n      model: 'M700',\n      contextSize: 512,\n      temperature: 0.7,\n      topP: 0.9,\n      confidence: 0.5,\n    };\n  }\n\n  /**\n   * Search memory for similar content\n   */\n  searchMemory(text: string, k = 10): MemoryResult[] {\n    if (this.native) {\n      const results = this.native.searchMemory(text, k);\n      return results.map(r => {\n        // The native side reports `distance` (smaller is closer). MemoryResult\n        // documents `score` as a similarity, so convert rather than passing a\n        // distance through under a similarity's name. Older builds that already\n        // emit `score` are used as-is.\n        const anyR = r as any;\n        const score =\n          typeof anyR.score === 'number'\n            ? anyR.score\n            : typeof anyR.distance === 'number'\n              ? 1 / (1 + Math.max(0, anyR.distance))\n              : 0;\n        return {\n          id: r.id,\n          score,\n          content: r.content,\n          metadata: JSON.parse(r.metadata || '{}'),\n        };\n      });\n    }\n\n    // Fallback - simple search\n    return Array.from(this.fallbackState.memory.entries())\n      .slice(0, k)\n      .map(([id, data]) => ({\n        id,\n        score: 0.5,\n        content: data.content,\n        metadata: data.metadata,\n      }));\n  }\n\n  /**\n   * Add content to memory\n   */\n  addMemory(content: string, metadata?: Record<string, unknown>): MemoryId {\n    if (this.native) {\n      return this.native.addMemory(content, metadata ? JSON.stringify(metadata) : undefined);\n    }\n\n    // Fallback\n    const id = this.fallbackState.nextId++;\n    this.fallbackState.memory.set(id, {\n      content,\n      embedding: this.embed(content),\n      metadata: metadata ?? {},\n    });\n    return id;\n  }\n\n  /**\n   * Provide feedback for learning\n   */\n  feedback(fb: Feedback): boolean {\n    if (this.native) {\n      return this.native.feedback(fb.requestId, fb.rating, fb.correction);\n    }\n    return false;\n  }\n\n  /**\n   * Get engine statistics\n   */\n  stats(): RuvLLMStats {\n    if (this.native) {\n      const s = this.native.stats();\n      // Map native stats (snake_case) to TypeScript interface (camelCase)\n      // Handle both old and new field names for backward compatibility\n      return {\n        totalQueries: (s as any).totalQueries ?? s.total_queries ?? 0,\n        memoryNodes: (s as any).memoryNodes ?? s.memory_nodes ?? 0,\n        patternsLearned:\n          (s as any).trainingSteps ??\n          s.patterns_learned ??\n          (s as any).training_steps ??\n          0,\n        avgLatencyMs: (s as any).avgLatencyMs ?? s.avg_latency_ms ?? 0,\n        cacheHitRate: (s as any).cacheHitRate ?? s.cache_hit_rate ?? 0,\n        routerAccuracy: (s as any).routerAccuracy ?? s.router_accuracy ?? 0.5,\n      };\n    }\n\n    // Fallback\n    return {\n      totalQueries: this.fallbackState.queryCount,\n      memoryNodes: this.fallbackState.memory.size,\n      patternsLearned: 0,\n      avgLatencyMs: 1.0,\n      cacheHitRate: 0.0,\n      routerAccuracy: 0.5,\n    };\n  }\n\n  /**\n   * Force router learning cycle\n   */\n  forceLearn(): string {\n    if (this.native) {\n      return this.native.forceLearn();\n    }\n    return 'Learning not available in fallback mode';\n  }\n\n  /**\n   * Get embedding for text\n   */\n  embed(text: string): Embedding {\n    if (this.native) {\n      return this.native.embed(text);\n    }\n\n    // Fallback - simple hash-based embedding\n    const dim = this.config.embeddingDim ?? 768;\n    const embedding = new Array(dim).fill(0);\n\n    for (let i = 0; i < text.length; i++) {\n      const idx = (text.charCodeAt(i) * (i + 1)) % dim;\n      embedding[idx] += 0.1;\n    }\n\n    // Normalize\n    const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0)) || 1;\n    return embedding.map(x => x / norm);\n  }\n\n  /**\n   * Compute similarity between two texts\n   */\n  similarity(text1: string, text2: string): number {\n    if (this.native) {\n      // f32 accumulation can land just outside the mathematical range — an\n      // identical pair measures 1.0000001 — which turns Math.acos(sim) into\n      // NaN downstream. Cosine similarity is defined on [-1, 1], so clamp.\n      const raw = this.native.similarity(text1, text2);\n      return Math.min(1, Math.max(-1, raw));\n    }\n\n    // Fallback - cosine similarity\n    const emb1 = this.embed(text1);\n    const emb2 = this.embed(text2);\n\n    let dot = 0;\n    let norm1 = 0;\n    let norm2 = 0;\n\n    for (let i = 0; i < emb1.length; i++) {\n      dot += emb1[i] * emb2[i];\n      norm1 += emb1[i] * emb1[i];\n      norm2 += emb2[i] * emb2[i];\n    }\n\n    const denom = Math.sqrt(norm1) * Math.sqrt(norm2);\n    const similarity = denom > 0 ? dot / denom : 0;\n    // Clamp to [0, 1] to handle floating point errors\n    return Math.max(0, Math.min(1, similarity));\n  }\n\n  /**\n   * Check if SIMD is available\n   */\n  hasSimd(): boolean {\n    if (this.native) {\n      return this.native.hasSimd();\n    }\n    return false;\n  }\n\n  /**\n   * Get SIMD capabilities\n   */\n  simdCapabilities(): string[] {\n    if (this.native) {\n      return this.native.simdCapabilities();\n    }\n    return ['Scalar (fallback)'];\n  }\n\n  /**\n   * Batch query multiple prompts\n   */\n  batchQuery(request: BatchQueryRequest): BatchQueryResponse {\n    const start = Date.now();\n    const responses = request.queries.map(q => this.query(q, request.config));\n    return {\n      responses,\n      totalLatencyMs: Date.now() - start,\n    };\n  }\n\n  /**\n   * Check if native module is loaded\n   */\n  isNativeLoaded(): boolean {\n    return this.native !== null;\n  }\n}\n"]}