getmy-ruflo 3.5.43

package/v3/@claude-flow/cli/bin/mcp-sse-server.js

@@ -0,0 +1,596 @@
+#!/usr/bin/env node
+/**
+ * @claude-flow/cli - Streamable HTTP MCP Server
+ *
+ * Implements the MCP Streamable HTTP transport specification (2025-11-05).
+ * Allows Claude Code to connect to remote Ruflo instances via the "url" field
+ * in mcpServers config.
+ *
+ * Usage:
+ *   node mcp-sse-server.js [--port 8080] [--host 0.0.0.0] [--token <bearer>]
+ */
+
+import { createServer } from 'http';
+import { randomUUID, timingSafeEqual } from 'crypto';
+import { listMCPTools, callMCPTool, hasTool, initializePluginTools } from '../dist/src/mcp-client.js';
+
+const VERSION = '3.0.0';
+const PROTOCOL_VERSION = '2025-11-05';
+const KEEPALIVE_INTERVAL_MS = 30_000;
+
+// ---------------------------------------------------------------------------
+// CLI arg parsing
+// ---------------------------------------------------------------------------
+const args = process.argv.slice(2);
+
+function getArg(name, fallback) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx === -1 || idx + 1 >= args.length) return fallback;
+  return args[idx + 1];
+}
+
+const port = parseInt(getArg('port', '8080'), 10);
+const host = getArg('host', '0.0.0.0');
+const token = getArg('token', '');
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+const sessions = new Map();       // sessionId -> { createdAt }
+const sseConnections = new Map(); // sessionId -> Set<res>
+const startTime = Date.now();
+
+// ---------------------------------------------------------------------------
+// Prometheus metrics counters
+// ---------------------------------------------------------------------------
+const metrics = {
+  toolCallsTotal: 0,
+  toolCallsByName: new Map(),
+  toolCallErrors: 0,
+  toolCallLatencySum: 0,
+  toolCallLatencyCount: 0,
+  sessionsCreated: 0,
+  sessionsTerminated: 0,
+  requestsTotal: 0,
+};
+
+// ---------------------------------------------------------------------------
+// Auth helper
+// ---------------------------------------------------------------------------
+function checkAuth(req, res) {
+  if (!token) return true;
+
+  const authHeader = req.headers['authorization'] || '';
+  const provided = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
+
+  if (!provided) {
+    res.writeHead(401, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Authorization required' }));
+    return false;
+  }
+
+  // Timing-safe comparison — pad to equal length
+  const expected = Buffer.from(token);
+  const actual = Buffer.from(provided);
+
+  if (expected.length !== actual.length) {
+    res.writeHead(403, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Forbidden' }));
+    return false;
+  }
+
+  if (!timingSafeEqual(expected, actual)) {
+    res.writeHead(403, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Forbidden' }));
+    return false;
+  }
+
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// CORS helper
+// ---------------------------------------------------------------------------
+function setCors(res) {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Mcp-Session-Id');
+  res.setHeader('Access-Control-Expose-Headers', 'Mcp-Session-Id');
+}
+
+// ---------------------------------------------------------------------------
+// MCP message handler (mirrors stdio server logic)
+// ---------------------------------------------------------------------------
+async function handleMessage(message, sessionId) {
+  if (!message.method) {
+    return {
+      jsonrpc: '2.0',
+      id: message.id ?? null,
+      error: { code: -32600, message: 'Invalid Request: missing method' },
+    };
+  }
+
+  const params = message.params || {};
+
+  try {
+    switch (message.method) {
+      case 'initialize': {
+        // Create or reuse session
+        const sid = sessionId || `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
+        sessions.set(sid, { createdAt: Date.now() });
+        metrics.sessionsCreated++;
+        return {
+          _sessionId: sid,
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {
+            protocolVersion: PROTOCOL_VERSION,
+            serverInfo: { name: 'claude-flow', version: VERSION },
+            capabilities: {
+              tools: { listChanged: true },
+              resources: { subscribe: true, listChanged: true },
+            },
+          },
+        };
+      }
+
+      case 'tools/list': {
+        const tools = listMCPTools();
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {
+            tools: tools.map((tool) => ({
+              name: tool.name,
+              description: tool.description,
+              inputSchema: tool.inputSchema,
+            })),
+          },
+        };
+      }
+
+      case 'tools/call': {
+        const toolName = params.name;
+        const toolParams = params.arguments || {};
+
+        if (!hasTool(toolName)) {
+          metrics.toolCallErrors++;
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: { code: -32601, message: `Tool not found: ${toolName}` },
+          };
+        }
+
+        const callStart = Date.now();
+        metrics.toolCallsTotal++;
+        metrics.toolCallsByName.set(toolName, (metrics.toolCallsByName.get(toolName) || 0) + 1);
+
+        try {
+          const result = await callMCPTool(toolName, toolParams, { sessionId: sessionId || 'http' });
+          metrics.toolCallLatencySum += Date.now() - callStart;
+          metrics.toolCallLatencyCount++;
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            result: {
+              content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            },
+          };
+        } catch (error) {
+          metrics.toolCallErrors++;
+          metrics.toolCallLatencySum += Date.now() - callStart;
+          metrics.toolCallLatencyCount++;
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: {
+              code: -32603,
+              message: error instanceof Error ? error.message : 'Tool execution failed',
+            },
+          };
+        }
+      }
+
+      case 'notifications/initialized':
+        console.error(`[${new Date().toISOString()}] INFO [ruflo-mcp] Client initialized (session: ${sessionId || 'none'})`);
+        return null; // notification — no response
+
+      case 'ping':
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {},
+        };
+
+      default:
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          error: { code: -32601, message: `Method not found: ${message.method}` },
+        };
+    }
+  } catch (error) {
+    console.error(`[${new Date().toISOString()}] ERROR [ruflo-mcp] ${message.method}:`, error);
+    return {
+      jsonrpc: '2.0',
+      id: message.id,
+      error: {
+        code: -32603,
+        message: error instanceof Error ? error.message : 'Internal error',
+      },
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Broadcast to SSE connections for a session
+// ---------------------------------------------------------------------------
+function broadcastSSE(sessionId, data) {
+  const conns = sseConnections.get(sessionId);
+  if (!conns) return;
+  const payload = `data: ${JSON.stringify(data)}\n\n`;
+  for (const conn of conns) {
+    try {
+      conn.write(payload);
+    } catch {
+      // connection may be closed
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Read full request body
+// ---------------------------------------------------------------------------
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', (chunk) => chunks.push(chunk));
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    req.on('error', reject);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Parse URL path (handles both /mcp and /mcp/ and query strings)
+// ---------------------------------------------------------------------------
+function parsePath(url) {
+  try {
+    const parsed = new URL(url, 'http://localhost');
+    return parsed.pathname.replace(/\/+$/, '') || '/';
+  } catch {
+    return url.split('?')[0].replace(/\/+$/, '') || '/';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// HTTP Server
+// ---------------------------------------------------------------------------
+const server = createServer(async (req, res) => {
+  setCors(res);
+  metrics.requestsTotal++;
+
+  // Handle CORS preflight
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  const path = parsePath(req.url);
+
+  // -----------------------------------------------------------------------
+  // GET /metrics — Prometheus metrics (no auth required for scraping)
+  // -----------------------------------------------------------------------
+  if (path === '/metrics' && req.method === 'GET') {
+    const lines = [];
+    const uptime = Math.floor((Date.now() - startTime) / 1000);
+    const tools = listMCPTools();
+
+    lines.push('# HELP ruflo_up Server is up');
+    lines.push('# TYPE ruflo_up gauge');
+    lines.push('ruflo_up 1');
+
+    lines.push('# HELP ruflo_uptime_seconds Server uptime');
+    lines.push('# TYPE ruflo_uptime_seconds gauge');
+    lines.push(`ruflo_uptime_seconds ${uptime}`);
+
+    lines.push('# HELP ruflo_tools_registered Number of registered tools');
+    lines.push('# TYPE ruflo_tools_registered gauge');
+    lines.push(`ruflo_tools_registered ${tools.length}`);
+
+    lines.push('# HELP ruflo_sessions_active Active MCP sessions');
+    lines.push('# TYPE ruflo_sessions_active gauge');
+    lines.push(`ruflo_sessions_active ${sessions.size}`);
+
+    lines.push('# HELP ruflo_sse_connections Active SSE connections');
+    lines.push('# TYPE ruflo_sse_connections gauge');
+    let sseTotal = 0;
+    for (const [, s] of sseConnections) sseTotal += s.size;
+    lines.push(`ruflo_sse_connections ${sseTotal}`);
+
+    lines.push('# HELP ruflo_sessions_created_total Sessions created');
+    lines.push('# TYPE ruflo_sessions_created_total counter');
+    lines.push(`ruflo_sessions_created_total ${metrics.sessionsCreated}`);
+
+    lines.push('# HELP ruflo_sessions_terminated_total Sessions terminated');
+    lines.push('# TYPE ruflo_sessions_terminated_total counter');
+    lines.push(`ruflo_sessions_terminated_total ${metrics.sessionsTerminated}`);
+
+    lines.push('# HELP ruflo_tool_calls_total Total tool calls');
+    lines.push('# TYPE ruflo_tool_calls_total counter');
+    lines.push(`ruflo_tool_calls_total ${metrics.toolCallsTotal}`);
+
+    lines.push('# HELP ruflo_tool_call_errors_total Tool call errors');
+    lines.push('# TYPE ruflo_tool_call_errors_total counter');
+    lines.push(`ruflo_tool_call_errors_total ${metrics.toolCallErrors}`);
+
+    lines.push('# HELP ruflo_tool_call_duration_seconds_sum Total tool call duration');
+    lines.push('# TYPE ruflo_tool_call_duration_seconds_sum counter');
+    lines.push(`ruflo_tool_call_duration_seconds_sum ${(metrics.toolCallLatencySum / 1000).toFixed(3)}`);
+
+    lines.push('# HELP ruflo_tool_call_duration_seconds_count Total tool call count');
+    lines.push('# TYPE ruflo_tool_call_duration_seconds_count counter');
+    lines.push(`ruflo_tool_call_duration_seconds_count ${metrics.toolCallLatencyCount}`);
+
+    lines.push('# HELP ruflo_tool_calls_by_name Tool calls by name');
+    lines.push('# TYPE ruflo_tool_calls_by_name counter');
+    for (const [name, count] of metrics.toolCallsByName) {
+      lines.push(`ruflo_tool_calls_by_name{tool="${name}"} ${count}`);
+    }
+
+    lines.push('# HELP ruflo_requests_total Total HTTP requests');
+    lines.push('# TYPE ruflo_requests_total counter');
+    lines.push(`ruflo_requests_total ${metrics.requestsTotal}`);
+
+    const mem = process.memoryUsage();
+    lines.push('# HELP ruflo_process_heap_bytes Heap memory used');
+    lines.push('# TYPE ruflo_process_heap_bytes gauge');
+    lines.push(`ruflo_process_heap_bytes ${mem.heapUsed}`);
+
+    lines.push('# HELP ruflo_process_rss_bytes RSS memory');
+    lines.push('# TYPE ruflo_process_rss_bytes gauge');
+    lines.push(`ruflo_process_rss_bytes ${mem.rss}`);
+
+    res.writeHead(200, { 'Content-Type': 'text/plain; version=0.0.4' });
+    res.end(lines.join('\n') + '\n');
+    return;
+  }
+
+  // Auth check
+  if (!checkAuth(req, res)) return;
+
+  // -----------------------------------------------------------------------
+  // GET /health — health check endpoint
+  // -----------------------------------------------------------------------
+  if (path === '/health' && req.method === 'GET') {
+    const tools = listMCPTools();
+    const uptimeSeconds = Math.floor((Date.now() - startTime) / 1000);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      tools: tools.length,
+      uptime: uptimeSeconds,
+      sessions: sessions.size,
+      protocolVersion: PROTOCOL_VERSION,
+    }));
+    return;
+  }
+
+  // -----------------------------------------------------------------------
+  // GET /mcp — SSE notification stream
+  // -----------------------------------------------------------------------
+  if (path === '/mcp' && req.method === 'GET') {
+    const sessionId = req.headers['mcp-session-id'] || null;
+
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'Mcp-Session-Id': sessionId || '',
+    });
+
+    // Send endpoint event so client knows where to POST
+    const endpointUrl = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}/mcp`;
+    res.write(`event: endpoint\ndata: ${endpointUrl}\n\n`);
+
+    // Track this SSE connection
+    if (sessionId) {
+      if (!sseConnections.has(sessionId)) {
+        sseConnections.set(sessionId, new Set());
+      }
+      sseConnections.get(sessionId).add(res);
+    }
+
+    // Keepalive timer
+    const keepalive = setInterval(() => {
+      try {
+        res.write(':keepalive\n\n');
+      } catch {
+        clearInterval(keepalive);
+      }
+    }, KEEPALIVE_INTERVAL_MS);
+
+    // Cleanup on close
+    req.on('close', () => {
+      clearInterval(keepalive);
+      if (sessionId && sseConnections.has(sessionId)) {
+        sseConnections.get(sessionId).delete(res);
+        if (sseConnections.get(sessionId).size === 0) {
+          sseConnections.delete(sessionId);
+        }
+      }
+    });
+
+    return;
+  }
+
+  // -----------------------------------------------------------------------
+  // POST /mcp — JSON-RPC request handling
+  // -----------------------------------------------------------------------
+  if (path === '/mcp' && req.method === 'POST') {
+    let body;
+    try {
+      body = await readBody(req);
+    } catch (error) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Failed to read body' } }));
+      return;
+    }
+
+    let message;
+    try {
+      message = JSON.parse(body);
+    } catch {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }));
+      return;
+    }
+
+    const sessionId = req.headers['mcp-session-id'] || null;
+    const wantsSSE = (req.headers['accept'] || '').includes('text/event-stream');
+
+    // Handle notifications (no id) — return 202 Accepted
+    if (message.method && message.id === undefined && message.id !== 0) {
+      await handleMessage(message, sessionId);
+      res.writeHead(202);
+      res.end();
+      return;
+    }
+
+    const response = await handleMessage(message, sessionId);
+
+    if (!response) {
+      // notification handler returned null
+      res.writeHead(202);
+      res.end();
+      return;
+    }
+
+    // Extract session ID from initialize response
+    const newSessionId = response._sessionId;
+    if (newSessionId) {
+      delete response._sessionId;
+    }
+
+    // Set session header
+    const responseSessionId = newSessionId || sessionId || '';
+    const headers = {
+      'Mcp-Session-Id': responseSessionId,
+    };
+
+    if (wantsSSE) {
+      // Respond as SSE stream
+      headers['Content-Type'] = 'text/event-stream';
+      headers['Cache-Control'] = 'no-cache';
+      headers['Connection'] = 'keep-alive';
+      res.writeHead(200, headers);
+      res.write(`data: ${JSON.stringify(response)}\n\n`);
+      res.end();
+    } else {
+      // Respond as plain JSON
+      headers['Content-Type'] = 'application/json';
+      res.writeHead(200, headers);
+      res.end(JSON.stringify(response));
+    }
+
+    // Also broadcast to any SSE listeners for this session
+    if (responseSessionId) {
+      broadcastSSE(responseSessionId, response);
+    }
+
+    return;
+  }
+
+  // -----------------------------------------------------------------------
+  // DELETE /mcp — session termination
+  // -----------------------------------------------------------------------
+  if (path === '/mcp' && req.method === 'DELETE') {
+    const sessionId = req.headers['mcp-session-id'] || null;
+    if (sessionId) {
+      sessions.delete(sessionId);
+      // Close SSE connections for this session
+      const conns = sseConnections.get(sessionId);
+      if (conns) {
+        for (const conn of conns) {
+          try { conn.end(); } catch { /* ignore */ }
+        }
+        sseConnections.delete(sessionId);
+      }
+      metrics.sessionsTerminated++;
+      console.error(`[${new Date().toISOString()}] INFO [ruflo-mcp] Session ${sessionId} terminated`);
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ status: 'session_terminated' }));
+    return;
+  }
+
+  // -----------------------------------------------------------------------
+  // 404 for anything else
+  // -----------------------------------------------------------------------
+  res.writeHead(404, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({ error: 'Not found', endpoints: ['POST /mcp', 'GET /mcp', 'GET /health', 'GET /metrics'] }));
+});
+
+// ---------------------------------------------------------------------------
+// Graceful shutdown
+// ---------------------------------------------------------------------------
+function shutdown(signal) {
+  console.error(`[${new Date().toISOString()}] INFO [ruflo-mcp] Received ${signal}, shutting down...`);
+
+  // Close all SSE connections
+  for (const [, conns] of sseConnections) {
+    for (const conn of conns) {
+      try { conn.end(); } catch { /* ignore */ }
+    }
+  }
+  sseConnections.clear();
+  sessions.clear();
+
+  server.close(() => {
+    console.error(`[${new Date().toISOString()}] INFO [ruflo-mcp] Server closed`);
+    process.exit(0);
+  });
+
+  // Force exit after 5 seconds if graceful shutdown hangs
+  setTimeout(() => process.exit(1), 5000).unref();
+}
+
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+
+// Load plugin tools before starting the server
+try {
+  const pluginToolCount = await initializePluginTools();
+  if (pluginToolCount > 0) {
+    console.error(`[${new Date().toISOString()}] INFO [ruflo-mcp] Loaded ${pluginToolCount} plugin tools`);
+  }
+} catch (error) {
+  console.error(`[${new Date().toISOString()}] WARN [ruflo-mcp] Plugin tool loading failed:`, error);
+}
+
+server.listen(port, host, () => {
+  const tools = listMCPTools();
+  console.error(`[${new Date().toISOString()}] INFO [ruflo-mcp] Streamable HTTP server listening on http://${host}:${port}/mcp`);
+  console.error(JSON.stringify({
+    arch: process.arch,
+    host,
+    mode: 'mcp-sse',
+    nodeVersion: process.version,
+    pid: process.pid,
+    platform: process.platform,
+    port,
+    protocol: 'streamable-http',
+    protocolVersion: PROTOCOL_VERSION,
+    tools: tools.length,
+    version: VERSION,
+  }));
+  console.error(`[ruflo-mcp] ${tools.length} tools registered`);
+  if (token) {
+    console.error(`[ruflo-mcp] Bearer token auth enabled`);
+  }
+});

package/v3/@claude-flow/cli/bin/preinstall.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+// Preinstall hook — no-op (cache repair removed in 3.1.0-alpha.53)

package/v3/@claude-flow/cli/dist/src/appliance/gguf-engine.d.ts

@@ -0,0 +1,91 @@
+/**
+ * ruvLLM GGUF Inference Engine -- Pure Node.js GGUF Model Interface
+ *
+ * Provides:
+ *   1. GGUF binary header parsing (metadata without loading weights)
+ *   2. Model loading abstraction (node-llama-cpp when available, metadata-only fallback)
+ *   3. Token generation interface with async iterator streaming
+ *   4. KV-cache persistence to RVF-compatible binary format
+ *
+ * Zero external dependencies. node-llama-cpp is an optional peer.
+ *
+ * @module @claude-flow/cli/appliance/gguf-engine
+ */
+export interface GgufMetadata {
+    magic: string;
+    version: number;
+    tensorCount: number;
+    kvCount: number;
+    architecture?: string;
+    name?: string;
+    contextLength?: number;
+    embeddingLength?: number;
+    blockCount?: number;
+    vocabSize?: number;
+    quantization?: string;
+    fileSize: number;
+    metadata: Record<string, unknown>;
+}
+export interface GgufEngineConfig {
+    contextSize?: number;
+    maxTokens?: number;
+    temperature?: number;
+    kvCachePath?: string;
+    verbose?: boolean;
+}
+export interface GenerateRequest {
+    prompt: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    stopSequences?: string[];
+}
+export interface GenerateResponse {
+    text: string;
+    model: string;
+    tokensUsed: number;
+    latencyMs: number;
+    metadataOnly: boolean;
+}
+/**
+ * Parse the header and metadata from a GGUF file without loading tensors.
+ * Reads only the first 256 KB of the file.
+ */
+export declare function parseGgufHeader(path: string): Promise<GgufMetadata>;
+export declare class GgufEngine {
+    private config;
+    private llamaCpp;
+    private llamaModel;
+    private llamaContext;
+    private loadedModels;
+    private activeModelPath;
+    private kvCache;
+    constructor(config: GgufEngineConfig);
+    /** Probe for node-llama-cpp availability. */
+    initialize(): Promise<void>;
+    /** Parse GGUF header and optionally load the model for inference. */
+    loadModel(path: string): Promise<GgufMetadata>;
+    /** Generate text. Delegates to node-llama-cpp or returns a metadata-only stub. */
+    generate(request: GenerateRequest): Promise<GenerateResponse>;
+    /** Stream tokens via async iterator. Falls back to yielding full response. */
+    stream(request: GenerateRequest): AsyncGenerator<string>;
+    /**
+     * Persist the KV cache to an RVF-compatible binary file.
+     * Format: RVKV magic | version u32 | model SHA-256 (32B) | entry count u32
+     *         entries: [key_len u32, key, val_len u32, val] | footer SHA-256 (32B)
+     */
+    persistKvCache(outputPath: string): Promise<void>;
+    /** Restore KV cache from an RVF-compatible binary file. */
+    loadKvCache(inputPath: string): Promise<void>;
+    /** Return metadata for all loaded models. */
+    getLoadedModels(): GgufMetadata[];
+    /** Store a key-value pair in the in-memory KV cache. */
+    setKvEntry(key: string, value: Buffer): void;
+    /** Retrieve a key-value pair from the in-memory KV cache. */
+    getKvEntry(key: string): Buffer | undefined;
+    /** Release resources, unload models, and optionally persist the KV cache. */
+    shutdown(): Promise<void>;
+    private tryLoadLlamaCpp;
+}
+//# sourceMappingURL=gguf-engine.d.ts.map

package/v3/@claude-flow/cli/dist/src/appliance/gguf-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gguf-engine.d.ts","sourceRoot":"","sources":["../../../src/appliance/gguf-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAmBH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACvB;AA6ED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAWzE;AAyED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,YAAY,CAAwC;IAC5D,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,OAAO,CAAkC;gBAErC,MAAM,EAAE,gBAAgB;IAUpC,6CAA6C;IACvC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,qEAAqE;IAC/D,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAqBpD,kFAAkF;IAC5E,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA6CnE,8EAA8E;IACvE,MAAM,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CAAC,MAAM,CAAC;IAuB/D;;;;OAIG;IACG,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BvD,2DAA2D;IACrD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCnD,6CAA6C;IAC7C,eAAe,IAAI,YAAY,EAAE;IAEjC,wDAAwD;IACxD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAE5C,6DAA6D;IAC7D,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAE3C,6EAA6E;IACvE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;YAiBjB,eAAe;CAI9B"}