monomind 1.11.3 → 1.11.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.11.3",
+  "version": "1.11.5",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/commands/benchmark.js

@@ -13,7 +13,7 @@ import { BenchmarkRunner } from '../benchmarks/benchmark-runner.js';
 // ============================================================================
 const pretrainCommand = {
     name: 'pretrain',
-    description: 'Benchmark self-learning pre-training system (SONA, EWC++, MoE)',
+    description: 'Benchmark pattern-learning pre-training system',
     options: [
         { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
         { name: 'warmup', short: 'w', type: 'number', description: 'Warmup iterations', default: '10' },
@@ -554,7 +554,7 @@ export const benchmarkCommand = {
         output.writeln(output.dim('─'.repeat(50)));
         output.writeln();
         output.writeln('Available subcommands:');
-        output.writeln(`  ${output.highlight('pretrain')}    - Benchmark self-learning pre-training (SONA, EWC++, MoE)`);
+        output.writeln(`  ${output.highlight('pretrain')}    - Benchmark pattern-learning pre-training`);
         output.writeln(`  ${output.highlight('neural')}      - Benchmark neural operations (embeddings, WASM)`);
         output.writeln(`  ${output.highlight('memory')}      - Benchmark memory operations (HNSW, store, search)`);
         output.writeln(`  ${output.highlight('all')}         - Run all benchmark suites`);

package/packages/@monomind/cli/dist/src/config-adapter.js

@@ -55,16 +55,10 @@ export function systemConfigToMonomindConfig(systemConfig) {
             autoExecute: false,
             hooks: [],
         },
-        // Neural / SONA learning configuration
+        // Neural pattern-learning configuration
         neural: {
             enabled: systemConfig.neural?.enabled ?? true,
             disableNative: systemConfig.neural?.disableNative ?? false,
-            sona: {
-                mode: systemConfig.neural?.sona?.mode ?? 'balanced',
-                learningRate: systemConfig.neural?.sona?.learningRate,
-                ewcLambda: systemConfig.neural?.sona?.ewcLambda,
-                embeddingDim: systemConfig.neural?.sona?.embeddingDim,
-            },
         },
     };
 }
@@ -143,19 +137,12 @@ export function configToSystemConfig(config) {
                 logging: true,
             },
         },
-        // Neural / SONA learning configuration — only emit when present so we don't
-        // synthesize a neural block for configs that never had one.
+        // Neural pattern-learning configuration — only emit when present
         ...(config.neural
             ? {
                 neural: {
                     enabled: config.neural.enabled ?? true,
                     disableNative: config.neural.disableNative ?? false,
-                    sona: {
-                        mode: config.neural.sona?.mode ?? 'balanced',
-                        learningRate: config.neural.sona?.learningRate,
-                        ewcLambda: config.neural.sona?.ewcLambda,
-                        embeddingDim: config.neural.sona?.embeddingDim,
-                    },
                 },
             }
             : {}),

package/packages/@monomind/cli/dist/src/index.d.ts

@@ -66,8 +66,6 @@ export * from './commands/index.js';
 export { MCPServerManager, createMCPServerManager, getServerManager, startMCPServer, stopMCPServer, getMCPServerStatus, type MCPServerOptions, type MCPServerStatus, } from './mcp-server.js';
 export { initializeMemoryDatabase, generateEmbedding, generateBatchEmbeddings, storeEntry, searchEntries, getHNSWIndex, addToHNSWIndex, searchHNSWIndex, getHNSWStatus, clearHNSWIndex, quantizeInt8, dequantizeInt8, quantizedCosineSim, getQuantizationStats, batchCosineSim, softmaxAttention, topKIndices, flashAttentionSearch, type MemoryInitResult, } from './memory/memory-initializer.js';
 export { initializeIntelligence, recordStep, recordTrajectory, findSimilarPatterns, getIntelligenceStats, getSonaCoordinator, getReasoningBank, clearIntelligence, benchmarkAdaptation, endTrajectoryWithVerdict, distillLearning, getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, type SonaConfig, type TrajectoryStep, type Pattern, type IntelligenceStats, } from './memory/intelligence.js';
-export { EWCConsolidator, getEWCConsolidator, resetEWCConsolidator, consolidatePatterns, recordPatternOutcome, getEWCStats, type PatternWeights, type EWCConfig, type ConsolidationResult, type EWCStats, } from './memory/ewc-consolidation.js';
-export { SONAOptimizer, getSONAOptimizer, resetSONAOptimizer, processTrajectory, getSuggestion, getSONAStats, type TrajectoryOutcome, type LearnedPattern, type RoutingSuggestion, type SONAStats, } from './memory/sona-optimizer.js';
 export { ErrorHandler, withErrorHandling, } from './production/error-handler.js';
 export type { ErrorContext, ErrorHandlerConfig, } from './production/error-handler.js';
 export { RateLimiter, createRateLimiter, } from './production/rate-limiter.js';

package/packages/@monomind/cli/dist/src/index.js

@@ -565,10 +565,6 @@ export { initializeIntelligence, recordStep, recordTrajectory, findSimilarPatter
 endTrajectoryWithVerdict, distillLearning, 
 // Pattern persistence API
 getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, } from './memory/intelligence.js';
-// EWC++ Consolidation (Prevents Catastrophic Forgetting)
-export { EWCConsolidator, getEWCConsolidator, resetEWCConsolidator, consolidatePatterns, recordPatternOutcome, getEWCStats, } from './memory/ewc-consolidation.js';
-// SONA Optimizer (Adaptive Routing via Trajectory Learning)
-export { SONAOptimizer, getSONAOptimizer, resetSONAOptimizer, processTrajectory, getSuggestion, getSONAStats, } from './memory/sona-optimizer.js';
 // Production Hardening
 export { ErrorHandler, withErrorHandling, } from './production/error-handler.js';
 export { RateLimiter, createRateLimiter, } from './production/rate-limiter.js';

package/packages/@monomind/cli/dist/src/mcp-server.js

@@ -900,12 +900,9 @@ export function getServerManager(options) {
  * Quick start MCP server
  */
 export async function startMCPServer(options) {
-    // A2: mark this as a long-lived host so the SONA write-path (trajectory record +
-    // consolidation) stays enabled. In one-shot CLI mode this env var is absent and
-    // the per-call SONA trajectory — which would never reach the consolidation
-    // threshold and is discarded on process exit — is skipped to avoid wasted
-    // ONNX/embedding overhead. Across MCP calls the registry singleton persists, so
-    // trajectories accumulate and DO reach threshold here.
+    // Mark as long-lived host so the intelligence/trajectory system stays enabled.
+    // In one-shot CLI mode trajectories are discarded on process exit; across
+    // MCP calls the registry singleton persists so patterns accumulate correctly.
     process.env.MONOMIND_PERSISTENT_HOST = '1';
     const manager = getServerManager(options);
     return await manager.start();

package/packages/@monomind/cli/dist/src/mcp-tools/hooks-tools.js

@@ -1475,7 +1475,7 @@ export const hooksBuildAgents = {
         const format = formatRaw;
         const persist = params.persist !== false; // Default to true
         const agents = [
-            { type: 'coder', configFile: join(outputDir, `coder.${format}`), capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['flash-attention', 'token-reduction'] },
+            { type: 'coder', configFile: join(outputDir, `coder.${format}`), capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['token-reduction', 'context-caching'] },
             { type: 'architect', configFile: join(outputDir, `architect.${format}`), capabilities: ['system-design', 'api-design', 'documentation'], optimizations: ['context-caching', 'memory-persistence'] },
             { type: 'tester', configFile: join(outputDir, `tester.${format}`), capabilities: ['unit-testing', 'integration-testing', 'coverage'], optimizations: ['parallel-execution'] },
             { type: 'security-architect', configFile: join(outputDir, `security-architect.${format}`), capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'], optimizations: ['pattern-matching'] },
@@ -1971,7 +1971,8 @@ export const hooksIntelligence = {
                 partial: [],
                 notImplemented: [],
                 removed: [
-                    'sona-optimizer', 'ewc-consolidation', 'moe-routing', 'flash-attention', 'lora-adapter'
+                    'moe-routing', 'flash-attention', 'lora-adapter',
+                    'native-sona-engine', 'native-router', 'native-attention',
                 ],
             },
             version: '3.0.0-alpha.102',

package/packages/@monomind/cli/dist/src/mcp-tools/monograph-compat.js

@@ -229,10 +229,9 @@ export function detectMonographChanges(db, opts, repoPath) {
     const affectedSymbols = [];
     const seenIds = new Set();
     for (const rel of changedFiles) {
-        // DB stores relative paths; try both relative and absolute to be safe
-        const nodes = getNodesForFile(db, rel).length > 0
-            ? getNodesForFile(db, rel)
-            : getNodesForFile(db, join(repoPath, rel));
+        // DB stores relative paths; try relative first, fall back to absolute
+        const relNodes = getNodesForFile(db, rel);
+        const nodes = relNodes.length > 0 ? relNodes : getNodesForFile(db, join(repoPath, rel));
         for (const n of nodes) {
             if (!seenIds.has(n.id)) {
                 seenIds.add(n.id);

package/packages/@monomind/cli/dist/src/types.d.ts

@@ -56,16 +56,10 @@ export interface MonomindConfig {
     neural?: NeuralConfig;
 }
 export interface NeuralConfig {
-    /** Enable neural/SONA learning (default: true) */
+    /** Enable pattern learning (default: true) */
     enabled?: boolean;
     /** Force pure-JS fallback, skip all native @monoes packages (default: false) */
     disableNative?: boolean;
-    sona?: {
-        mode?: 'real-time' | 'balanced' | 'research' | 'edge' | 'batch';
-        learningRate?: number;
-        ewcLambda?: number;
-        embeddingDim?: number;
-    };
 }
 export interface AgentConfig {
     defaultType: string;

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.11.3",
+  "version": "1.11.5",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",

package/scripts/build-monovector.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 set -e
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-PACKAGES=(learning-wasm exotic-wasm attention-wasm gnn-wasm ruvllm-wasm rvagent-wasm)
+PACKAGES=(learning-wasm exotic-wasm attention-wasm gnn-wasm)
 for pkg in "${PACKAGES[@]}"; do
   echo "Building @monovector/$pkg..."
   (cd "$REPO_ROOT/packages/@monoes/$pkg" && npm run build)

package/scripts/publish-monovector.sh

@@ -6,7 +6,7 @@
 set -e
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 
-PACKAGES=(learning-wasm exotic-wasm attention-wasm gnn-wasm ruvllm-wasm rvagent-wasm)
+PACKAGES=(learning-wasm exotic-wasm attention-wasm gnn-wasm)
 
 for pkg in "${PACKAGES[@]}"; do
   PKG_DIR="$REPO_ROOT/packages/@monoes/$pkg/pkg"

package/scripts/verify-appliance.sh

@@ -423,24 +423,7 @@ if should_run "rvf"; then
   rm -rf "$RVF_DIR"
 fi
 
-# ── 27. Local Model Inference (ruvLLM from RuVector) ──────────
-if should_run "ruvllm"; then
-  section 27 "Local Model Inference (ruvLLM / RuVector)"
-  if [ "${SKIP_MODELS:-0}" = "1" ]; then
-    check_skip "ruvllm: model load" "SKIP_MODELS=1"
-    check_skip "ruvllm: tokenize" "SKIP_MODELS=1"
-    check_skip "ruvllm: generate" "SKIP_MODELS=1"
-    check_skip "ruvllm: stream" "SKIP_MODELS=1"
-  elif command -v monomind-ruvllm >/dev/null 2>&1; then
-    check_warn "ruvllm: engine available" monomind-ruvllm --version
-    check_warn "ruvllm: model list" monomind-ruvllm models list
-    check_warn "ruvllm: tokenize" monomind-ruvllm tokenize --text "Hello world"
-    check_warn "ruvllm: generate" monomind-ruvllm generate --prompt "2+2=" --max-tokens 10
-  else
-    check_skip "ruvllm: engine" "monomind-ruvllm not installed (future: ADR-058 Phase 3)"
-    check_skip "ruvllm: inference" "monomind-ruvllm not installed"
-  fi
-fi
+# Section 27 (local model inference) was removed — native LLM module not in lean build
 
 # ── 28. API Key Vault ─────────────────────────────────────────
 if should_run "vault"; then

package/packages/@monomind/cli/dist/src/mcp-tools/ruvllm-tools.d.ts

@@ -1,9 +0,0 @@
-/**
- * MonoVector LLM WASM MCP Tools
- *
- * Exposes @monoes/ruvllm-wasm operations via MCP protocol.
- * All tools gracefully degrade when the WASM package is not installed.
- */
-import type { MCPTool } from './types.js';
-export declare const ruvllmWasmTools: MCPTool[];
-//# sourceMappingURL=ruvllm-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/ruvllm-tools.js

@@ -1,295 +0,0 @@
-/**
- * MonoVector LLM WASM MCP Tools
- *
- * Exposes @monoes/ruvllm-wasm operations via MCP protocol.
- * All tools gracefully degrade when the WASM package is not installed.
- */
-async function loadRuvllmWasm() {
-    return import('../monovector/ruvllm-wasm.js');
-}
-// ── Instance Registries ──────────────────────────────────────
-const hnswRouters = new Map();
-const sonaInstances = new Map();
-const loraInstances = new Map();
-// ── Map eviction (prevents WASM object leaks in long-running MCP servers) ────
-const MAX_MAP_SIZE = 50;
-function setWithEviction(map, key, value) {
-    if (map.size >= MAX_MAP_SIZE) {
-        // Evict the oldest entry (first inserted)
-        const firstKey = map.keys().next().value;
-        map.delete(firstKey);
-    }
-    map.set(key, value);
-}
-export const ruvllmWasmTools = [
-    {
-        name: 'ruvllm_status',
-        description: 'Get ruvllm-wasm availability and initialization status.',
-        inputSchema: { type: 'object', properties: {} },
-        handler: async () => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const status = await mod.getRuvllmStatus();
-                return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_hnsw_create',
-        description: 'Create a WASM HNSW router for semantic pattern routing. Max ~11 patterns (v2.0.1 limit).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                dimensions: { type: 'number', description: 'Embedding dimensions (e.g., 64, 128, 384)' },
-                maxPatterns: { type: 'number', description: 'Max patterns capacity (limit ~11 in v2.0.1)' },
-                efSearch: { type: 'number', description: 'HNSW ef search parameter (higher = more accurate, slower)' },
-            },
-            required: ['dimensions', 'maxPatterns'],
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const router = await mod.createHnswRouter({
-                    dimensions: args.dimensions,
-                    maxPatterns: args.maxPatterns,
-                    efSearch: args.efSearch,
-                });
-                // Store router in module-level registry
-                const id = `hnsw-${Date.now().toString(36)}`;
-                setWithEviction(hnswRouters, id, router);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, routerId: id, dimensions: args.dimensions, maxPatterns: args.maxPatterns }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_hnsw_add',
-        description: 'Add a pattern to an HNSW router. Embedding must match router dimensions.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                routerId: { type: 'string', description: 'HNSW router ID from ruvllm_hnsw_create' },
-                name: { type: 'string', description: 'Pattern name/label' },
-                embedding: { type: 'array', items: { type: 'number' }, description: 'Float array embedding vector' },
-                metadata: { type: 'object', description: 'Optional metadata object' },
-            },
-            required: ['routerId', 'name', 'embedding'],
-        },
-        handler: async (args) => {
-            try {
-                const router = hnswRouters.get(args.routerId);
-                if (!router)
-                    return { content: [{ type: 'text', text: JSON.stringify({ error: `Router not found: ${args.routerId}` }) }], isError: true };
-                const embedding = new Float32Array(args.embedding);
-                const ok = router.addPattern({
-                    name: args.name,
-                    embedding,
-                    metadata: args.metadata,
-                });
-                return { content: [{ type: 'text', text: JSON.stringify({ success: ok, patternCount: router.patternCount() }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_hnsw_route',
-        description: 'Route a query embedding to nearest patterns in HNSW index.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                routerId: { type: 'string', description: 'HNSW router ID' },
-                query: { type: 'array', items: { type: 'number' }, description: 'Query embedding vector' },
-                k: { type: 'number', description: 'Number of nearest neighbors (default: 3)' },
-            },
-            required: ['routerId', 'query'],
-        },
-        handler: async (args) => {
-            try {
-                const router = hnswRouters.get(args.routerId);
-                if (!router)
-                    return { content: [{ type: 'text', text: JSON.stringify({ error: `Router not found: ${args.routerId}` }) }], isError: true };
-                const query = new Float32Array(args.query);
-                const k = typeof args.k === 'number' && args.k > 0 ? Math.floor(args.k) : 3;
-                const results = router.route(query, k);
-                return { content: [{ type: 'text', text: JSON.stringify({ results }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_sona_create',
-        description: 'Create a SONA instant adaptation loop (<1ms adaptation cycles).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                hiddenDim: { type: 'number', description: 'Hidden dimension (default: 64)' },
-                learningRate: { type: 'number', description: 'Learning rate (default: 0.01)' },
-                patternCapacity: { type: 'number', description: 'Max stored patterns' },
-            },
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const sona = await mod.createSonaInstant({
-                    hiddenDim: args.hiddenDim,
-                    learningRate: args.learningRate,
-                    patternCapacity: args.patternCapacity,
-                });
-                const id = `sona-${Date.now().toString(36)}`;
-                setWithEviction(sonaInstances, id, sona);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, sonaId: id }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_sona_adapt',
-        description: 'Run SONA instant adaptation with a quality signal.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sonaId: { type: 'string', description: 'SONA instance ID' },
-                quality: { type: 'number', description: 'Quality signal (0.0-1.0)' },
-            },
-            required: ['sonaId', 'quality'],
-        },
-        handler: async (args) => {
-            try {
-                const sona = sonaInstances.get(args.sonaId);
-                if (!sona)
-                    return { content: [{ type: 'text', text: JSON.stringify({ error: `SONA not found: ${args.sonaId}` }) }], isError: true };
-                sona.adapt(args.quality);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, stats: sona.stats() }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_microlora_create',
-        description: 'Create a MicroLoRA adapter (ultra-lightweight LoRA, ranks 1-4).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                inputDim: { type: 'number', description: 'Input dimension' },
-                outputDim: { type: 'number', description: 'Output dimension' },
-                rank: { type: 'number', description: 'LoRA rank (1-4, default: 2)' },
-                alpha: { type: 'number', description: 'LoRA alpha scaling (default: 1.0)' },
-            },
-            required: ['inputDim', 'outputDim'],
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const lora = await mod.createMicroLora({
-                    inputDim: args.inputDim,
-                    outputDim: args.outputDim,
-                    rank: args.rank,
-                    alpha: args.alpha,
-                });
-                const id = `lora-${Date.now().toString(36)}`;
-                setWithEviction(loraInstances, id, lora);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, loraId: id }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_microlora_adapt',
-        description: 'Adapt MicroLoRA weights with quality feedback.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                loraId: { type: 'string', description: 'MicroLoRA instance ID' },
-                quality: { type: 'number', description: 'Quality signal (0.0-1.0)' },
-                learningRate: { type: 'number', description: 'Learning rate (default: 0.01)' },
-                success: { type: 'boolean', description: 'Whether the adaptation was successful (default: true)' },
-            },
-            required: ['loraId', 'quality'],
-        },
-        handler: async (args) => {
-            try {
-                const lora = loraInstances.get(args.loraId);
-                if (!lora)
-                    return { content: [{ type: 'text', text: JSON.stringify({ error: `MicroLoRA not found: ${args.loraId}` }) }], isError: true };
-                lora.adapt(args.quality, args.learningRate, args.success);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, stats: lora.stats() }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_chat_format',
-        description: 'Format chat messages using a template (llama3, mistral, chatml, phi, gemma, or auto-detect).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                messages: {
-                    type: 'array',
-                    items: { type: 'object', properties: { role: { type: 'string' }, content: { type: 'string' } }, required: ['role', 'content'] },
-                    description: 'Array of {role, content} message objects',
-                },
-                template: { type: 'string', description: 'Template preset (llama3, mistral, chatml, phi, gemma) or model ID for auto-detection' },
-            },
-            required: ['messages', 'template'],
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const messages = args.messages;
-                const templateStr = args.template;
-                const presets = ['llama3', 'mistral', 'chatml', 'phi', 'gemma'];
-                const template = presets.includes(templateStr)
-                    ? templateStr
-                    : { modelId: templateStr };
-                const formatted = await mod.formatChat(messages, template);
-                return { content: [{ type: 'text', text: formatted }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_generate_config',
-        description: 'Create a generation config (maxTokens, temperature, topP, etc.) as JSON.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                maxTokens: { type: 'number', description: 'Max tokens to generate' },
-                temperature: { type: 'number', description: 'Sampling temperature (note: f32 precision)' },
-                topP: { type: 'number', description: 'Top-p sampling' },
-                topK: { type: 'number', description: 'Top-k sampling' },
-                repetitionPenalty: { type: 'number', description: 'Repetition penalty' },
-                stopSequences: { type: 'array', items: { type: 'string' }, description: 'Stop sequences' },
-            },
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const config = await mod.createGenerateConfig(args);
-                return { content: [{ type: 'text', text: config }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-];
-//# sourceMappingURL=ruvllm-tools.js.map