@ruvector/ruvllm 2.6.2 → 3.0.0

package/dist/cjs/engine.js

@@ -3,7 +3,7 @@
  * RuvLLM Engine - Main orchestrator for self-learning LLM
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuvLLM = void 0;
+exports.RuvLLM = exports.PLACEHOLDER_TEXT = void 0;
 const native_1 = require("./native");
 /**
  * Convert JS config to native config format
@@ -28,31 +28,109 @@ function toNativeConfig(config) {
 function toNativeGenConfig(config) {
     if (!config)
         return undefined;
+    // camelCase: napi-rs ignores snake_case keys on `#[napi(object)]` inputs.
     return {
-        max_tokens: config.maxTokens,
+        maxTokens: config.maxTokens,
         temperature: config.temperature,
-        top_p: config.topP,
-        top_k: config.topK,
-        repetition_penalty: config.repetitionPenalty,
+        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`. */
+exports.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 SIMD-optimized inference.
+ * 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({ embeddingDim: 768 });
+ * const llm = new RuvLLM();
+ * llm.loadModel('./qwen2.5-0.5b-instruct-q4_k_m.gguf');
  *
- * // Query with automatic routing
- * const response = await llm.query('What is machine learning?');
- * console.log(response.text);
+ * const out = llm.chat([{ role: 'user', content: 'What is machine learning?' }], {
+ *   maxTokens: 128,
+ * });
+ * console.log(out.text, out.finishReason, out.completionTokens);
  *
- * // Provide feedback for learning
+ * // Routed query, answered by the loaded model
+ * const response = llm.query('What is machine learning?');
  * llm.feedback({ requestId: response.requestId, rating: 5 });
  * ```
  */
@@ -62,6 +140,7 @@ class RuvLLM {
      */
     constructor(config) {
         this.native = null;
+        this.nativeVersion = null;
         // Fallback state for when native module is not available
         this.fallbackState = {
             memory: new Map(),
@@ -69,72 +148,202 @@ class RuvLLM {
             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 = (0, native_1.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)));
     }
     /**
-     * Query the LLM with automatic routing
+     * 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.native) {
-            const result = this.native.query(text, toNativeGenConfig(config));
-            // napi-rs camelCases Rust field names on the way out, so the native
-            // object carries `contextSize`/`latencyMs`/`requestId`. The snake_case
-            // reads are kept as a fallback for older native builds.
+        if (!this.isModelLoaded()) {
+            const placeholder = this.placeholderOrThrow();
+            this.fallbackState.queryCount++;
+            const route = this.route(text);
             return {
-                text: result.text,
-                confidence: result.confidence,
-                model: result.model,
-                contextSize: result.contextSize ?? result.context_size,
-                latencyMs: result.latencyMs ?? result.latency_ms,
-                requestId: result.requestId ?? result.request_id,
+                text: placeholder,
+                confidence: route.confidence,
+                model: route.model,
+                contextSize: route.contextSize,
+                latencyMs: 0,
+                requestId: `placeholder-${Date.now()}-${Math.random().toString(36).slice(2)}`,
             };
         }
-        // Fallback implementation
-        this.fallbackState.queryCount++;
+        const native = this.native;
+        const result = callNative(() => native.query(text, toNativeGenConfig(config)));
         return {
-            text: `[Fallback] Response to: ${text.slice(0, 50)}...`,
-            confidence: 0.5,
-            model: 'fallback',
-            contextSize: 512,
-            latencyMs: 1.0,
-            requestId: `fb-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            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,
         };
     }
     /**
-     * Generate text with SIMD-optimized inference
+     * Continue `prompt` verbatim with the loaded model (no chat template; use
+     * `chat()` for instruction-tuned models). Returns the generated text.
      *
-     * Note: If no trained model is loaded (demo mode), returns an informational
-     * message instead of garbled output.
+     * @throws `RUVLLM_NO_LANGUAGE_MODEL` when no model is loaded, unless
+     *   `allowPlaceholder` is set (then it returns `PLACEHOLDER_TEXT`).
      */
     generate(prompt, config) {
-        if (this.native) {
-            return this.native.generate(prompt, toNativeGenConfig(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)';
         }
-        // Fallback - provide helpful message instead of garbled output
-        const maxTokens = config?.maxTokens ?? 256;
-        const temp = config?.temperature ?? 0.7;
-        const topP = config?.topP ?? 0.9;
-        return `[RuvLLM JavaScript Fallback Mode]
-No native SIMD module loaded. Running in JavaScript fallback mode.
-
-Your prompt: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"
-
-To enable native SIMD inference:
-1. Install the native bindings: npm install @ruvector/ruvllm-${process.platform}-${process.arch}
-2. Or load a GGUF model file
-3. Or connect to an external LLM API
-
-Config: temp=${temp.toFixed(2)}, top_p=${topP.toFixed(2)}, max_tokens=${maxTokens}
-
-This fallback provides routing, memory, and embedding features but not full text generation.`;
+        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 exports.PLACEHOLDER_TEXT;
     }
     /**
      * Get routing decision for a query
@@ -340,4 +549,4 @@ This fallback provides routing, memory, and embedding features but not full text
     }
 }
 exports.RuvLLM = RuvLLM;
-//# 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} from './types';\n\nimport {\n  getNativeModule,\n  NativeEngine,\n  NativeConfig,\n  NativeGenConfig,\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  return {\n    max_tokens: config.maxTokens,\n    temperature: config.temperature,\n    top_p: config.topP,\n    top_k: config.topK,\n    repetition_penalty: config.repetitionPenalty,\n  };\n}\n\n/**\n * RuvLLM - Self-learning LLM orchestrator\n *\n * Combines SONA adaptive learning with HNSW memory,\n * FastGRNN routing, and SIMD-optimized inference.\n *\n * @example\n * ```typescript\n * import { RuvLLM } from '@ruvector/ruvllm';\n *\n * const llm = new RuvLLM({ embeddingDim: 768 });\n *\n * // Query with automatic routing\n * const response = await llm.query('What is machine learning?');\n * console.log(response.text);\n *\n * // Provide feedback for learning\n * llm.feedback({ requestId: response.requestId, rating: 5 });\n * ```\n */\nexport class RuvLLM {\n  private native: NativeEngine | null = null;\n  private config: RuvLLMConfig;\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\n    const mod = getNativeModule();\n    if (mod) {\n      try {\n        this.native = new mod.RuvLLMEngine(toNativeConfig(config));\n      } catch {\n        // Silently fall back to JS implementation\n      }\n    }\n  }\n\n  /**\n   * Query the LLM with automatic routing\n   */\n  query(text: string, config?: GenerationConfig): QueryResponse {\n    if (this.native) {\n      const result = this.native.query(text, toNativeGenConfig(config));\n      // napi-rs camelCases Rust field names on the way out, so the native\n      // object carries `contextSize`/`latencyMs`/`requestId`. The snake_case\n      // reads are kept as a fallback for older native builds.\n      return {\n        text: result.text,\n        confidence: result.confidence,\n        model: result.model,\n        contextSize: result.contextSize ?? result.context_size,\n        latencyMs: result.latencyMs ?? result.latency_ms,\n        requestId: result.requestId ?? result.request_id,\n      };\n    }\n\n    // Fallback implementation\n    this.fallbackState.queryCount++;\n    return {\n      text: `[Fallback] Response to: ${text.slice(0, 50)}...`,\n      confidence: 0.5,\n      model: 'fallback',\n      contextSize: 512,\n      latencyMs: 1.0,\n      requestId: `fb-${Date.now()}-${Math.random().toString(36).slice(2)}`,\n    };\n  }\n\n  /**\n   * Generate text with SIMD-optimized inference\n   *\n   * Note: If no trained model is loaded (demo mode), returns an informational\n   * message instead of garbled output.\n   */\n  generate(prompt: string, config?: GenerationConfig): string {\n    if (this.native) {\n      return this.native.generate(prompt, toNativeGenConfig(config));\n    }\n\n    // Fallback - provide helpful message instead of garbled output\n    const maxTokens = config?.maxTokens ?? 256;\n    const temp = config?.temperature ?? 0.7;\n    const topP = config?.topP ?? 0.9;\n\n    return `[RuvLLM JavaScript Fallback Mode]\nNo native SIMD module loaded. Running in JavaScript fallback mode.\n\nYour prompt: \"${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}\"\n\nTo enable native SIMD inference:\n1. Install the native bindings: npm install @ruvector/ruvllm-${process.platform}-${process.arch}\n2. Or load a GGUF model file\n3. Or connect to an external LLM API\n\nConfig: temp=${temp.toFixed(2)}, top_p=${topP.toFixed(2)}, max_tokens=${maxTokens}\n\nThis fallback provides routing, memory, and embedding features but not full text generation.`;\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"]}
+//# 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"]}

package/dist/cjs/native.d.ts

@@ -21,7 +21,24 @@ interface NativeConfig {
 }
 interface NativeEngine {
     query(text: string, config?: NativeGenConfig): NativeQueryResponse;
-    generate(prompt: string, config?: NativeGenConfig): string;
+    /**
+     * Builds with `loadModel` return a generation result and throw while no
+     * model is loaded; older builds (the 2.0.x platform packages) return a
+     * string that is not model output, so the wrapper never calls them.
+     */
+    generate(prompt: string, config?: NativeGenConfig): NativeGenerationResult | string;
+    /**
+     * Present on builds since model loading was added. Those built without the
+     * `candle` feature throw `RUVLLM_NO_INFERENCE_BACKEND`; see
+     * `supportsModelLoading`.
+     */
+    loadModel?(path: string, options?: NativeLoadModelOptions): NativeModelInfo;
+    /** Whether the binary was built with the `candle` feature (absent on older builds). */
+    supportsModelLoading?(): boolean;
+    unloadModel?(): void;
+    isModelLoaded?(): boolean;
+    modelInfo?(): NativeModelInfo | null;
+    chat?(messages: NativeChatMessage[], config?: NativeGenConfig): NativeGenerationResult;
     route(text: string): NativeRoutingDecision;
     searchMemory(text: string, k?: number): NativeMemoryResult[];
     /** Current native builds return a UUID string; older ones returned a number. */
@@ -35,11 +52,38 @@ interface NativeEngine {
     simdCapabilities(): string[];
 }
 interface NativeGenConfig {
-    max_tokens?: number;
+    maxTokens?: number;
     temperature?: number;
-    top_p?: number;
-    top_k?: number;
-    repetition_penalty?: number;
+    topP?: number;
+    topK?: number;
+    repetitionPenalty?: number;
+    stopSequences?: string[];
+    seed?: number;
+}
+interface NativeLoadModelOptions {
+    maxContext?: number;
+}
+interface NativeChatMessage {
+    role: string;
+    content: string;
+}
+interface NativeGenerationResult {
+    text: string;
+    promptTokens: number;
+    completionTokens: number;
+    finishReason: string;
+}
+interface NativeModelInfo {
+    name: string;
+    architecture: string;
+    numParameters: number;
+    vocabSize: number;
+    hiddenSize: number;
+    numLayers: number;
+    maxContextLength: number;
+    quantization?: string | null;
+    memoryUsageBytes: number;
+    chatTemplate?: string | null;
 }
 interface NativeQueryResponse {
     text: string;
@@ -48,6 +92,10 @@ interface NativeQueryResponse {
     contextSize: number;
     latencyMs: number;
     requestId: string;
+    /** Builds with `loadModel` also report token usage. */
+    promptTokens?: number;
+    completionTokens?: number;
+    finishReason?: string;
     context_size?: number;
     latency_ms?: number;
     request_id?: string;
@@ -88,5 +136,5 @@ interface NativeSimdOps {
 export declare function getNativeModule(): NativeRuvLLM | null;
 export declare function version(): string;
 export declare function hasSimdSupport(): boolean;
-export type { NativeRuvLLM, NativeConfig, NativeEngine, NativeGenConfig, NativeQueryResponse, NativeRoutingDecision, NativeMemoryResult, NativeStats, NativeSimdOps, };
+export type { NativeRuvLLM, NativeConfig, NativeEngine, NativeGenConfig, NativeLoadModelOptions, NativeChatMessage, NativeGenerationResult, NativeModelInfo, NativeQueryResponse, NativeRoutingDecision, NativeMemoryResult, NativeStats, NativeSimdOps, };
 //# sourceMappingURL=native.d.ts.map