@ruvector/ruvllm 4.0.0 → 4.1.0

package/dist/cjs/native.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Native bindings loader for RuvLLM
+ *
+ * Automatically loads the correct native binary for the current platform.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNativeModule = getNativeModule;
+exports.version = version;
+exports.hasSimdSupport = hasSimdSupport;
+const path_1 = require("path");
+// Try to load the native module
+let nativeModule = null;
+// Platform-specific package names
+const PLATFORM_PACKAGES = {
+    'darwin-x64': '@ruvector/ruvllm-darwin-x64',
+    'darwin-arm64': '@ruvector/ruvllm-darwin-arm64',
+    'linux-x64': '@ruvector/ruvllm-linux-x64-gnu',
+    'linux-arm64': '@ruvector/ruvllm-linux-arm64-gnu',
+    'win32-x64': '@ruvector/ruvllm-win32-x64-msvc',
+};
+function getPlatformKey() {
+    const platform = process.platform;
+    const arch = process.arch;
+    return `${platform}-${arch}`;
+}
+function loadNativeModule() {
+    if (nativeModule) {
+        return nativeModule;
+    }
+    // An explicit binary (e.g. one built locally with `npm run build:native`)
+    // wins over the installed platform package. Failing to load it is an
+    // error, not a silent fallback to a different binary.
+    const override = process.env.RUVLLM_NATIVE_PATH;
+    if (override) {
+        try {
+            // resolve(): a relative path means relative to the working directory,
+            // not to this file.
+            nativeModule = normalize(require((0, path_1.resolve)(override)));
+            return nativeModule;
+        }
+        catch (e) {
+            throw new Error(`RUVLLM_NATIVE_PATH=${override} could not be loaded: ${e.message}`);
+        }
+    }
+    const platformKey = getPlatformKey();
+    const packageName = PLATFORM_PACKAGES[platformKey];
+    if (!packageName) {
+        // Silently fail - JS fallback will be used
+        return null;
+    }
+    // `napi build --platform` names its output ruvllm.<platform>.node
+    const platformFile = `ruvllm.${packageName.replace('@ruvector/ruvllm-', '')}.node`;
+    // Try loading from optional dependencies
+    const attempts = [
+        // Try the platform-specific package
+        () => require(packageName),
+        // Try loading from local .node file (CJS build)
+        () => require((0, path_1.join)(__dirname, '..', '..', 'ruvllm.node')),
+        // Try loading from local .node file (root)
+        () => require((0, path_1.join)(__dirname, '..', 'ruvllm.node')),
+        // Output of `npm run build:native` in the package root
+        () => require((0, path_1.join)(__dirname, '..', '..', platformFile)),
+    ];
+    for (const attempt of attempts) {
+        try {
+            nativeModule = normalize(attempt());
+            return nativeModule;
+        }
+        catch {
+            // Continue to next attempt
+        }
+    }
+    // Silently fall back to JS implementation
+    return null;
+}
+// Normalize: native exports RuvLlmEngine, we expose as RuvLLMEngine
+function normalize(raw) {
+    return {
+        RuvLLMEngine: raw.RuvLLMEngine ?? raw.RuvLlmEngine,
+        SimdOperations: raw.SimdOperations,
+        version: raw.version,
+        hasSimdSupport: raw.hasSimdSupport,
+    };
+}
+// Export functions to get native bindings
+function getNativeModule() {
+    return loadNativeModule();
+}
+function version() {
+    const mod = loadNativeModule();
+    return mod?.version() ?? '0.1.0-js';
+}
+function hasSimdSupport() {
+    const mod = loadNativeModule();
+    return mod?.hasSimdSupport() ?? false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native.js","sourceRoot":"","sources":["../../src/native.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;AA0PH,0CAEC;AAED,0BAGC;AAED,wCAGC;AApQD,+BAAqC;AAErC,gCAAgC;AAChC,IAAI,YAAY,GAAwB,IAAI,CAAC;AAkK7C,kCAAkC;AAClC,MAAM,iBAAiB,GAA2B;IAChD,YAAY,EAAE,6BAA6B;IAC3C,cAAc,EAAE,+BAA+B;IAC/C,WAAW,EAAE,gCAAgC;IAC7C,aAAa,EAAE,kCAAkC;IACjD,WAAW,EAAE,iCAAiC;CAC/C,CAAC;AAEF,SAAS,cAAc;IACrB,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAClC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,OAAO,GAAG,QAAQ,IAAI,IAAI,EAAE,CAAC;AAC/B,CAAC;AAED,SAAS,gBAAgB;IACvB,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,0EAA0E;IAC1E,qEAAqE;IACrE,sDAAsD;IACtD,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IAChD,IAAI,QAAQ,EAAE,CAAC;QACb,IAAI,CAAC;YACH,sEAAsE;YACtE,oBAAoB;YACpB,YAAY,GAAG,SAAS,CAAC,OAAO,CAAC,IAAA,cAAO,EAAC,QAAQ,CAAC,CAAoB,CAAC,CAAC;YACxE,OAAO,YAAY,CAAC;QACtB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CACb,sBAAsB,QAAQ,yBAA0B,CAAW,CAAC,OAAO,EAAE,CAC9E,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IACrC,MAAM,WAAW,GAAG,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAEnD,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,2CAA2C;QAC3C,OAAO,IAAI,CAAC;IACd,CAAC;IACD,kEAAkE;IAClE,MAAM,YAAY,GAAG,UAAU,WAAW,CAAC,OAAO,CAAC,mBAAmB,EAAE,EAAE,CAAC,OAAO,CAAC;IAEnF,yCAAyC;IACzC,MAAM,QAAQ,GAAG;QACf,oCAAoC;QACpC,GAAG,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC;QAC1B,gDAAgD;QAChD,GAAG,EAAE,CAAC,OAAO,CAAC,IAAA,WAAI,EAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC;QACzD,2CAA2C;QAC3C,GAAG,EAAE,CAAC,OAAO,CAAC,IAAA,WAAI,EAAC,SAAS,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC;QACnD,uDAAuD;QACvD,GAAG,EAAE,CAAC,OAAO,CAAC,IAAA,WAAI,EAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;KACzD,CAAC;IAEF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC;YACH,YAAY,GAAG,SAAS,CAAC,OAAO,EAAqB,CAAC,CAAC;YACvD,OAAO,YAAY,CAAC;QACtB,CAAC;QAAC,MAAM,CAAC;YACP,2BAA2B;QAC7B,CAAC;IACH,CAAC;IAED,0CAA0C;IAC1C,OAAO,IAAI,CAAC;AACd,CAAC;AAED,oEAAoE;AACpE,SAAS,SAAS,CAAC,GAAoB;IACrC,OAAO;QACL,YAAY,EAAE,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,YAAa;QACnD,cAAc,EAAE,GAAG,CAAC,cAAc;QAClC,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,cAAc,EAAE,GAAG,CAAC,cAAc;KACnC,CAAC;AACJ,CAAC;AAED,0CAA0C;AAC1C,SAAgB,eAAe;IAC7B,OAAO,gBAAgB,EAAE,CAAC;AAC5B,CAAC;AAED,SAAgB,OAAO;IACrB,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAC/B,OAAO,GAAG,EAAE,OAAO,EAAE,IAAI,UAAU,CAAC;AACtC,CAAC;AAED,SAAgB,cAAc;IAC5B,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAC/B,OAAO,GAAG,EAAE,cAAc,EAAE,IAAI,KAAK,CAAC;AACxC,CAAC","sourcesContent":["/**\n * Native bindings loader for RuvLLM\n *\n * Automatically loads the correct native binary for the current platform.\n */\n\nimport { join, resolve } from 'path';\n\n// Try to load the native module\nlet nativeModule: NativeRuvLLM | null = null;\n\ninterface NativeRuvLLM {\n  // Native exports RuvLlmEngine (camelCase), we normalize to RuvLLMEngine\n  RuvLLMEngine: new (config?: NativeConfig) => NativeEngine;\n  SimdOperations: new () => NativeSimdOps;\n  version: () => string;\n  hasSimdSupport: () => boolean;\n}\n\n// Raw native module interface (actual export names)\ninterface RawNativeModule {\n  RuvLlmEngine?: new (config?: NativeConfig) => NativeEngine;\n  RuvLLMEngine?: new (config?: NativeConfig) => NativeEngine;\n  SimdOperations: new () => NativeSimdOps;\n  version: () => string;\n  hasSimdSupport: () => boolean;\n}\n\ninterface NativeConfig {\n  embedding_dim?: number;\n  router_hidden_dim?: number;\n  hnsw_m?: number;\n  hnsw_ef_construction?: number;\n  hnsw_ef_search?: number;\n  learning_enabled?: boolean;\n  quality_threshold?: number;\n  ewc_lambda?: number;\n}\n\ninterface NativeEngine {\n  query(text: string, config?: NativeGenConfig): NativeQueryResponse;\n  /**\n   * Builds with `loadModel` return a generation result and throw while no\n   * model is loaded; older builds (the 2.0.x platform packages) return a\n   * string that is not model output, so the wrapper never calls them.\n   */\n  generate(prompt: string, config?: NativeGenConfig): NativeGenerationResult | string;\n  /**\n   * Present on builds since model loading was added. Those built without the\n   * `candle` feature throw `RUVLLM_NO_INFERENCE_BACKEND`; see\n   * `supportsModelLoading`.\n   */\n  loadModel?(path: string, options?: NativeLoadModelOptions): NativeModelInfo;\n  /** Whether the binary was built with the `candle` feature (absent on older builds). */\n  supportsModelLoading?(): boolean;\n  unloadModel?(): void;\n  isModelLoaded?(): boolean;\n  modelInfo?(): NativeModelInfo | null;\n  chat?(messages: NativeChatMessage[], config?: NativeGenConfig): NativeGenerationResult;\n  route(text: string): NativeRoutingDecision;\n  searchMemory(text: string, k?: number): NativeMemoryResult[];\n  /** Current native builds return a UUID string; older ones returned a number. */\n  addMemory(content: string, metadata?: string): string | number;\n  feedback(requestId: string, rating: number, correction?: string): boolean;\n  stats(): NativeStats;\n  forceLearn(): string;\n  embed(text: string): number[];\n  similarity(text1: string, text2: string): number;\n  hasSimd(): boolean;\n  simdCapabilities(): string[];\n}\n\n// napi-rs reads `#[napi(object)]` fields by their camelCase names; snake_case\n// keys are silently ignored (which is how `maxTokens` used to be dropped).\ninterface NativeGenConfig {\n  maxTokens?: number;\n  temperature?: number;\n  topP?: number;\n  topK?: number;\n  repetitionPenalty?: number;\n  stopSequences?: string[];\n  seed?: number;\n}\n\ninterface NativeLoadModelOptions {\n  maxContext?: number;\n}\n\ninterface NativeChatMessage {\n  role: string;\n  content: string;\n}\n\ninterface NativeGenerationResult {\n  text: string;\n  promptTokens: number;\n  completionTokens: number;\n  finishReason: string;\n}\n\ninterface NativeModelInfo {\n  name: string;\n  architecture: string;\n  numParameters: number;\n  vocabSize: number;\n  hiddenSize: number;\n  numLayers: number;\n  maxContextLength: number;\n  quantization?: string | null;\n  memoryUsageBytes: number;\n  chatTemplate?: string | null;\n}\n\n// napi-rs camelCases Rust struct fields when it builds the JS object, so the\n// real native shape is camelCase. These interfaces previously declared only\n// snake_case, which is why the wrapper's snake_case reads typechecked while\n// silently yielding undefined at runtime. Both spellings are declared —\n// camelCase required, snake_case optional — so older native builds still fit.\ninterface NativeQueryResponse {\n  text: string;\n  confidence: number;\n  model: string;\n  contextSize: number;\n  latencyMs: number;\n  requestId: string;\n  /** Builds with `loadModel` also report token usage. */\n  promptTokens?: number;\n  completionTokens?: number;\n  finishReason?: string;\n  context_size?: number;\n  latency_ms?: number;\n  request_id?: string;\n}\n\ninterface NativeRoutingDecision {\n  model: string;\n  contextSize: number;\n  temperature: number;\n  top_p?: number;\n  topP: number;\n  confidence: number;\n  context_size?: number;\n}\n\ninterface NativeMemoryResult {\n  id: string | number;\n  /** Distance (smaller is closer) as reported by the current native build. */\n  distance?: number;\n  /** Similarity, emitted by older native builds. */\n  score?: number;\n  content: string;\n  metadata: string;\n}\n\ninterface NativeStats {\n  total_queries: number;\n  memory_nodes: number;\n  patterns_learned: number;\n  avg_latency_ms: number;\n  cache_hit_rate: number;\n  router_accuracy: number;\n}\n\ninterface NativeSimdOps {\n  dotProduct(a: number[], b: number[]): number;\n  cosineSimilarity(a: number[], b: number[]): number;\n  l2Distance(a: number[], b: number[]): number;\n  matvec(matrix: number[][], vector: number[]): number[];\n  softmax(input: number[]): number[];\n}\n\n// Platform-specific package names\nconst PLATFORM_PACKAGES: Record<string, string> = {\n  'darwin-x64': '@ruvector/ruvllm-darwin-x64',\n  'darwin-arm64': '@ruvector/ruvllm-darwin-arm64',\n  'linux-x64': '@ruvector/ruvllm-linux-x64-gnu',\n  'linux-arm64': '@ruvector/ruvllm-linux-arm64-gnu',\n  'win32-x64': '@ruvector/ruvllm-win32-x64-msvc',\n};\n\nfunction getPlatformKey(): string {\n  const platform = process.platform;\n  const arch = process.arch;\n  return `${platform}-${arch}`;\n}\n\nfunction loadNativeModule(): NativeRuvLLM | null {\n  if (nativeModule) {\n    return nativeModule;\n  }\n\n  // An explicit binary (e.g. one built locally with `npm run build:native`)\n  // wins over the installed platform package. Failing to load it is an\n  // error, not a silent fallback to a different binary.\n  const override = process.env.RUVLLM_NATIVE_PATH;\n  if (override) {\n    try {\n      // resolve(): a relative path means relative to the working directory,\n      // not to this file.\n      nativeModule = normalize(require(resolve(override)) as RawNativeModule);\n      return nativeModule;\n    } catch (e) {\n      throw new Error(\n        `RUVLLM_NATIVE_PATH=${override} could not be loaded: ${(e as Error).message}`,\n      );\n    }\n  }\n\n  const platformKey = getPlatformKey();\n  const packageName = PLATFORM_PACKAGES[platformKey];\n\n  if (!packageName) {\n    // Silently fail - JS fallback will be used\n    return null;\n  }\n  // `napi build --platform` names its output ruvllm.<platform>.node\n  const platformFile = `ruvllm.${packageName.replace('@ruvector/ruvllm-', '')}.node`;\n\n  // Try loading from optional dependencies\n  const attempts = [\n    // Try the platform-specific package\n    () => require(packageName),\n    // Try loading from local .node file (CJS build)\n    () => require(join(__dirname, '..', '..', 'ruvllm.node')),\n    // Try loading from local .node file (root)\n    () => require(join(__dirname, '..', 'ruvllm.node')),\n    // Output of `npm run build:native` in the package root\n    () => require(join(__dirname, '..', '..', platformFile)),\n  ];\n\n  for (const attempt of attempts) {\n    try {\n      nativeModule = normalize(attempt() as RawNativeModule);\n      return nativeModule;\n    } catch {\n      // Continue to next attempt\n    }\n  }\n\n  // Silently fall back to JS implementation\n  return null;\n}\n\n// Normalize: native exports RuvLlmEngine, we expose as RuvLLMEngine\nfunction normalize(raw: RawNativeModule): NativeRuvLLM {\n  return {\n    RuvLLMEngine: raw.RuvLLMEngine ?? raw.RuvLlmEngine!,\n    SimdOperations: raw.SimdOperations,\n    version: raw.version,\n    hasSimdSupport: raw.hasSimdSupport,\n  };\n}\n\n// Export functions to get native bindings\nexport function getNativeModule(): NativeRuvLLM | null {\n  return loadNativeModule();\n}\n\nexport function version(): string {\n  const mod = loadNativeModule();\n  return mod?.version() ?? '0.1.0-js';\n}\n\nexport function hasSimdSupport(): boolean {\n  const mod = loadNativeModule();\n  return mod?.hasSimdSupport() ?? false;\n}\n\n// Export types for internal use\nexport type {\n  NativeRuvLLM,\n  NativeConfig,\n  NativeEngine,\n  NativeGenConfig,\n  NativeLoadModelOptions,\n  NativeChatMessage,\n  NativeGenerationResult,\n  NativeModelInfo,\n  NativeQueryResponse,\n  NativeRoutingDecision,\n  NativeMemoryResult,\n  NativeStats,\n  NativeSimdOps,\n};\n"]}

package/dist/cjs/session.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Session Management for multi-turn conversations
+ */
+import { ConversationSession, ConversationMessage, QueryResponse, GenerationConfig } from './types';
+/**
+ * Session Manager for multi-turn conversations
+ *
+ * @example
+ * ```typescript
+ * import { RuvLLM, SessionManager } from '@ruvector/ruvllm';
+ *
+ * const llm = new RuvLLM();
+ * const sessions = new SessionManager(llm);
+ *
+ * // Create a new session
+ * const session = sessions.create();
+ *
+ * // Chat with context
+ * const response1 = sessions.chat(session.id, 'What is Python?');
+ * const response2 = sessions.chat(session.id, 'How do I install it?');
+ * // Second query automatically has context from first
+ * ```
+ */
+export declare class SessionManager {
+    private sessions;
+    private llm;
+    constructor(llm: {
+        query: (text: string, config?: GenerationConfig) => QueryResponse;
+        addMemory: (content: string, metadata?: Record<string, unknown>) => number;
+    });
+    /**
+     * Create a new conversation session
+     */
+    create(metadata?: Record<string, unknown>): ConversationSession;
+    /**
+     * Get session by ID
+     */
+    get(sessionId: string): ConversationSession | undefined;
+    /**
+     * Chat within a session (maintains context)
+     */
+    chat(sessionId: string, message: string, config?: GenerationConfig): QueryResponse;
+    /**
+     * Add system message to session
+     */
+    addSystemMessage(sessionId: string, content: string): void;
+    /**
+     * Add context to session (persisted to memory)
+     */
+    addContext(sessionId: string, context: string): number;
+    /**
+     * Get conversation history
+     */
+    getHistory(sessionId: string, limit?: number): ConversationMessage[];
+    /**
+     * Clear session history (keep session active)
+     */
+    clearHistory(sessionId: string): void;
+    /**
+     * End and delete session
+     */
+    end(sessionId: string): boolean;
+    /**
+     * List all active sessions
+     */
+    list(): ConversationSession[];
+    /**
+     * Export session as JSON
+     */
+    export(sessionId: string): string | null;
+    /**
+     * Import session from JSON
+     */
+    import(json: string): ConversationSession;
+    /**
+     * Build context string from recent messages
+     */
+    private buildContext;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/cjs/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,GAAG,CAAoJ;gBAEnJ,GAAG,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,KAAK,aAAa,CAAC;QAAC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAA;KAAE;IAIlK;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,mBAAmB;IAe/D;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIvD;;OAEG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,aAAa;IAiClF;;OAEG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAc1D;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAmBtD;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,mBAAmB,EAAE;IAUpE;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IASrC;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B;;OAEG;IACH,IAAI,IAAI,mBAAmB,EAAE;IAI7B;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASxC;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB;IAezC;;OAEG;IACH,OAAO,CAAC,YAAY;CA2BrB"}

package/dist/cjs/session.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Session Management for multi-turn conversations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+/**
+ * Session Manager for multi-turn conversations
+ *
+ * @example
+ * ```typescript
+ * import { RuvLLM, SessionManager } from '@ruvector/ruvllm';
+ *
+ * const llm = new RuvLLM();
+ * const sessions = new SessionManager(llm);
+ *
+ * // Create a new session
+ * const session = sessions.create();
+ *
+ * // Chat with context
+ * const response1 = sessions.chat(session.id, 'What is Python?');
+ * const response2 = sessions.chat(session.id, 'How do I install it?');
+ * // Second query automatically has context from first
+ * ```
+ */
+class SessionManager {
+    constructor(llm) {
+        this.sessions = new Map();
+        this.llm = llm;
+    }
+    /**
+     * Create a new conversation session
+     */
+    create(metadata) {
+        const id = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const session = {
+            id,
+            createdAt: new Date(),
+            messageCount: 0,
+            messages: [],
+            context: [],
+            activeMemoryIds: [],
+            metadata: metadata ?? {},
+        };
+        this.sessions.set(id, session);
+        return session;
+    }
+    /**
+     * Get session by ID
+     */
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Chat within a session (maintains context)
+     */
+    chat(sessionId, message, config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Add user message
+        session.messages.push({
+            role: 'user',
+            content: message,
+            timestamp: new Date(),
+        });
+        // Build context from recent messages
+        const contextWindow = this.buildContext(session);
+        // Query with context
+        const prompt = contextWindow ? `${contextWindow}\n\nUser: ${message}` : message;
+        const response = this.llm.query(prompt, config);
+        // Add assistant response
+        session.messages.push({
+            role: 'assistant',
+            content: response.text,
+            timestamp: new Date(),
+            requestId: response.requestId,
+        });
+        session.messageCount = session.messages.length;
+        return response;
+    }
+    /**
+     * Add system message to session
+     */
+    addSystemMessage(sessionId, content) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        session.messages.push({
+            role: 'system',
+            content,
+            timestamp: new Date(),
+        });
+        session.messageCount = session.messages.length;
+    }
+    /**
+     * Add context to session (persisted to memory)
+     */
+    addContext(sessionId, context) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        session.context.push(context);
+        // Also store in memory for retrieval
+        const memoryId = this.llm.addMemory(context, {
+            sessionId,
+            type: 'context',
+            timestamp: new Date().toISOString(),
+        });
+        session.activeMemoryIds.push(memoryId);
+        return memoryId;
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory(sessionId, limit) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return [];
+        }
+        const messages = session.messages;
+        return limit ? messages.slice(-limit) : messages;
+    }
+    /**
+     * Clear session history (keep session active)
+     */
+    clearHistory(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.messages = [];
+            session.context = [];
+            session.messageCount = 0;
+        }
+    }
+    /**
+     * End and delete session
+     */
+    end(sessionId) {
+        return this.sessions.delete(sessionId);
+    }
+    /**
+     * List all active sessions
+     */
+    list() {
+        return Array.from(this.sessions.values());
+    }
+    /**
+     * Export session as JSON
+     */
+    export(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return null;
+        }
+        return JSON.stringify(session, null, 2);
+    }
+    /**
+     * Import session from JSON
+     */
+    import(json) {
+        const data = JSON.parse(json);
+        const session = {
+            ...data,
+            createdAt: new Date(data.createdAt),
+            messages: data.messages.map((m) => ({
+                ...m,
+                timestamp: new Date(m.timestamp),
+            })),
+        };
+        this.sessions.set(session.id, session);
+        return session;
+    }
+    /**
+     * Build context string from recent messages
+     */
+    buildContext(session, maxMessages = 10) {
+        const recent = session.messages.slice(-maxMessages);
+        if (recent.length === 0) {
+            return '';
+        }
+        const contextParts = [];
+        // Add persistent context
+        if (session.context.length > 0) {
+            contextParts.push('Context:\n' + session.context.join('\n'));
+        }
+        // Add conversation history
+        const history = recent
+            .map(m => {
+            const role = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : 'System';
+            return `${role}: ${m.content}`;
+        })
+            .join('\n');
+        if (history) {
+            contextParts.push('Conversation:\n' + history);
+        }
+        return contextParts.join('\n\n');
+    }
+}
+exports.SessionManager = SessionManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Session Management for multi-turn conversations\n */\n\nimport {\n  ConversationSession,\n  ConversationMessage,\n  QueryResponse,\n  GenerationConfig,\n} from './types';\n\n/**\n * Session Manager for multi-turn conversations\n *\n * @example\n * ```typescript\n * import { RuvLLM, SessionManager } from '@ruvector/ruvllm';\n *\n * const llm = new RuvLLM();\n * const sessions = new SessionManager(llm);\n *\n * // Create a new session\n * const session = sessions.create();\n *\n * // Chat with context\n * const response1 = sessions.chat(session.id, 'What is Python?');\n * const response2 = sessions.chat(session.id, 'How do I install it?');\n * // Second query automatically has context from first\n * ```\n */\nexport class SessionManager {\n  private sessions: Map<string, ConversationSession> = new Map();\n  private llm: { query: (text: string, config?: GenerationConfig) => QueryResponse; addMemory: (content: string, metadata?: Record<string, unknown>) => number };\n\n  constructor(llm: { query: (text: string, config?: GenerationConfig) => QueryResponse; addMemory: (content: string, metadata?: Record<string, unknown>) => number }) {\n    this.llm = llm;\n  }\n\n  /**\n   * Create a new conversation session\n   */\n  create(metadata?: Record<string, unknown>): ConversationSession {\n    const id = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n    const session: ConversationSession = {\n      id,\n      createdAt: new Date(),\n      messageCount: 0,\n      messages: [],\n      context: [],\n      activeMemoryIds: [],\n      metadata: metadata ?? {},\n    };\n    this.sessions.set(id, session);\n    return session;\n  }\n\n  /**\n   * Get session by ID\n   */\n  get(sessionId: string): ConversationSession | undefined {\n    return this.sessions.get(sessionId);\n  }\n\n  /**\n   * Chat within a session (maintains context)\n   */\n  chat(sessionId: string, message: string, config?: GenerationConfig): QueryResponse {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session not found: ${sessionId}`);\n    }\n\n    // Add user message\n    session.messages.push({\n      role: 'user',\n      content: message,\n      timestamp: new Date(),\n    });\n\n    // Build context from recent messages\n    const contextWindow = this.buildContext(session);\n\n    // Query with context\n    const prompt = contextWindow ? `${contextWindow}\\n\\nUser: ${message}` : message;\n    const response = this.llm.query(prompt, config);\n\n    // Add assistant response\n    session.messages.push({\n      role: 'assistant',\n      content: response.text,\n      timestamp: new Date(),\n      requestId: response.requestId,\n    });\n\n    session.messageCount = session.messages.length;\n\n    return response;\n  }\n\n  /**\n   * Add system message to session\n   */\n  addSystemMessage(sessionId: string, content: string): void {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session not found: ${sessionId}`);\n    }\n\n    session.messages.push({\n      role: 'system',\n      content,\n      timestamp: new Date(),\n    });\n    session.messageCount = session.messages.length;\n  }\n\n  /**\n   * Add context to session (persisted to memory)\n   */\n  addContext(sessionId: string, context: string): number {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session not found: ${sessionId}`);\n    }\n\n    session.context.push(context);\n\n    // Also store in memory for retrieval\n    const memoryId = this.llm.addMemory(context, {\n      sessionId,\n      type: 'context',\n      timestamp: new Date().toISOString(),\n    });\n\n    session.activeMemoryIds.push(memoryId);\n    return memoryId;\n  }\n\n  /**\n   * Get conversation history\n   */\n  getHistory(sessionId: string, limit?: number): ConversationMessage[] {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      return [];\n    }\n\n    const messages = session.messages;\n    return limit ? messages.slice(-limit) : messages;\n  }\n\n  /**\n   * Clear session history (keep session active)\n   */\n  clearHistory(sessionId: string): void {\n    const session = this.sessions.get(sessionId);\n    if (session) {\n      session.messages = [];\n      session.context = [];\n      session.messageCount = 0;\n    }\n  }\n\n  /**\n   * End and delete session\n   */\n  end(sessionId: string): boolean {\n    return this.sessions.delete(sessionId);\n  }\n\n  /**\n   * List all active sessions\n   */\n  list(): ConversationSession[] {\n    return Array.from(this.sessions.values());\n  }\n\n  /**\n   * Export session as JSON\n   */\n  export(sessionId: string): string | null {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      return null;\n    }\n\n    return JSON.stringify(session, null, 2);\n  }\n\n  /**\n   * Import session from JSON\n   */\n  import(json: string): ConversationSession {\n    const data = JSON.parse(json);\n    const session: ConversationSession = {\n      ...data,\n      createdAt: new Date(data.createdAt),\n      messages: data.messages.map((m: ConversationMessage) => ({\n        ...m,\n        timestamp: new Date(m.timestamp),\n      })),\n    };\n\n    this.sessions.set(session.id, session);\n    return session;\n  }\n\n  /**\n   * Build context string from recent messages\n   */\n  private buildContext(session: ConversationSession, maxMessages = 10): string {\n    const recent = session.messages.slice(-maxMessages);\n    if (recent.length === 0) {\n      return '';\n    }\n\n    const contextParts: string[] = [];\n\n    // Add persistent context\n    if (session.context.length > 0) {\n      contextParts.push('Context:\\n' + session.context.join('\\n'));\n    }\n\n    // Add conversation history\n    const history = recent\n      .map(m => {\n        const role = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : 'System';\n        return `${role}: ${m.content}`;\n      })\n      .join('\\n');\n\n    if (history) {\n      contextParts.push('Conversation:\\n' + history);\n    }\n\n    return contextParts.join('\\n\\n');\n  }\n}\n"]}

package/dist/cjs/simd.d.ts

@@ -0,0 +1,90 @@
+/**
+ * SIMD Operations for vector computations
+ *
+ * Uses native SIMD instructions (AVX2/AVX512/SSE4.1/NEON) when available,
+ * falls back to JavaScript implementations otherwise.
+ */
+/**
+ * SIMD Operations class
+ *
+ * Provides hardware-accelerated vector operations when native module is available.
+ *
+ * @example
+ * ```typescript
+ * import { SimdOps } from '@ruvector/ruvllm';
+ *
+ * const simd = new SimdOps();
+ *
+ * // Compute dot product
+ * const result = simd.dotProduct([1, 2, 3], [4, 5, 6]);
+ * console.log(result); // 32
+ *
+ * // Check capabilities
+ * console.log(simd.capabilities()); // ['AVX2', 'FMA']
+ * ```
+ */
+export declare class SimdOps {
+    private native;
+    constructor();
+    /**
+     * Compute dot product of two vectors
+     */
+    dotProduct(a: number[], b: number[]): number;
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    cosineSimilarity(a: number[], b: number[]): number;
+    /**
+     * Compute L2 (Euclidean) distance between two vectors
+     */
+    l2Distance(a: number[], b: number[]): number;
+    /**
+     * Matrix-vector multiplication
+     */
+    matvec(matrix: number[][], vector: number[]): number[];
+    /**
+     * Softmax activation function
+     */
+    softmax(input: number[]): number[];
+    /**
+     * Element-wise addition
+     */
+    add(a: number[], b: number[]): number[];
+    /**
+     * Element-wise multiplication
+     */
+    mul(a: number[], b: number[]): number[];
+    /**
+     * Scale vector by scalar
+     */
+    scale(a: number[], scalar: number): number[];
+    /**
+     * Normalize vector to unit length
+     */
+    normalize(a: number[]): number[];
+    /**
+     * ReLU activation
+     */
+    relu(input: number[]): number[];
+    /**
+     * GELU activation (approximate)
+     */
+    gelu(input: number[]): number[];
+    /**
+     * Sigmoid activation
+     */
+    sigmoid(input: number[]): number[];
+    /**
+     * Layer normalization
+     */
+    layerNorm(input: number[], eps?: number): number[];
+    /**
+     * Check if native SIMD is available
+     */
+    isNative(): boolean;
+    /**
+     * Get available SIMD capabilities
+     */
+    capabilities(): string[];
+}
+//# sourceMappingURL=simd.d.ts.map

package/dist/cjs/simd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simd.d.ts","sourceRoot":"","sources":["../../src/simd.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,MAAM,CAA8B;;IAa5C;;OAEG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM;IAc5C;;OAEG;IACH,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM;IAqBlD;;OAEG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM;IAe5C;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAStD;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAYlC;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IASvC;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IASvC;;OAEG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAI5C;;OAEG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAKhC;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAI/B;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAM/B;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAIlC;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,SAAO,GAAG,MAAM,EAAE;IAOhD;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;CAkBzB"}