@vibecodetown/mcp-server 1.3.1 → 1.4.0

package/build/bitnet-worker/server.js

@@ -25,21 +25,22 @@
  *   VIBE_BITNET_MODEL       - Path to GGUF model
  *   VIBE_BITNET_THREADS     - CPU thread count
  */
-import * as http from "node:http";
-import { getMetrics } from "./metrics.js";
-import { TieredQueue } from "./tiered_queue.js";
-import { extractTierFromHeaders, logSlotLimits } from "./hw_slots.js";
-import { shouldBrake, createOverloadResponse, logCpuStatus } from "./cpu_brake.js";
-import { RequestCache, sha256Json } from "./request_cache.js";
-import { bitnetCheck, bitnetTrace, bitnetSignal, VALID_RISK_TAGS, } from "../mcp/tools/bitnet/index.js";
-import { getNativeInference, isNativeInferenceEnabled, buildNativePrompt, parseNativeOutput, } from "./native_inference.js";
-import { getServerManager, isServerModeEnabled, ensureServerRunning, } from "./server_manager.js";
-import { createLivenessHandler, createReadinessHandler, modelLoadedChecker, queueHealthChecker, } from "../health/index.js";
+import * as http from 'node:http';
+import { getMetrics } from './metrics.js';
+import { TieredQueue } from './tiered_queue.js';
+import { extractTierFromHeaders, logSlotLimits, } from './hw_slots.js';
+import { shouldBrake, createOverloadResponse, logCpuStatus } from './cpu_brake.js';
+import { RequestCache, sha256Json } from './request_cache.js';
+import { bitnetCheck, bitnetTrace, bitnetSignal, enrichContextFromChains, VALID_RISK_TAGS, } from '../mcp/tools/bitnet/index.js';
+import { getNativeInference, isNativeInferenceEnabled, buildNativePrompt, parseNativeOutput, } from './native_inference.js';
+import { getServerManager, ensureServerRunning, } from './server_manager.js';
+import { createLivenessHandler, createReadinessHandler, modelLoadedChecker, queueHealthChecker, } from '../health/index.js';
+import { logger } from '../shared/logger.js';
 // ============================================================
 // Queue + Cache (tier-based concurrency)
 // ============================================================
 function getCacheTtlMs() {
-    const raw = Number(process.env.VIBE_BITNET_WORKER_CACHE_TTL_MS ?? "");
+    const raw = Number(process.env.VIBE_BITNET_WORKER_CACHE_TTL_MS ?? '');
     if (Number.isFinite(raw) && raw >= 0)
         return raw;
     return 60_000;
@@ -58,52 +59,44 @@ const signalCache = new RequestCache({ ttlMs: getCacheTtlMs() });
 async function runNativeCheck(files, context) {
     try {
         const prompt = buildNativePrompt(files, context);
-        let rawOutput;
-        if (isServerModeEnabled()) {
-            // Server mode: use HTTP API
-            const serverManager = await ensureServerRunning();
-            rawOutput = await serverManager.infer(prompt);
-        }
-        else {
-            // CLI mode: spawn binary
-            const nativeInference = getNativeInference();
-            const inferResult = await nativeInference.infer(prompt);
-            if (inferResult.error) {
-                console.error(`[BitNet Native] Inference error: ${inferResult.error}`);
-                return null;
-            }
-            rawOutput = inferResult.output;
+        // CLI mode: spawn binary
+        const nativeInference = getNativeInference();
+        const inferResult = await nativeInference.infer(prompt);
+        if (inferResult.error) {
+            logger.error(`[BitNet Native] Inference error: ${inferResult.error}`);
+            return null;
         }
+        const rawOutput = inferResult.output;
         // Parse the JSON output
         const parsed = parseNativeOutput(rawOutput);
         if (!parsed) {
-            console.error(`[BitNet Native] Failed to parse output: ${rawOutput.slice(0, 200)}`);
+            logger.error(`[BitNet Native] Failed to parse output: ${rawOutput.slice(0, 200)}`);
             return null;
         }
         // Convert native output to BitNetCheckResult format
         // Map verdict: native uses OK/WARN/STOP, our format uses GO/WARNING/BLOCK
-        const rawVerdict = (parsed.verdict || "OK").toUpperCase();
-        let verdict = "GO";
-        let status = "OK";
-        if (rawVerdict === "WARN" || rawVerdict === "WARNING") {
-            verdict = "WARNING";
-            status = "WARNING";
+        const rawVerdict = (parsed.verdict || 'OK').toUpperCase();
+        let verdict = 'GO';
+        let status = 'OK';
+        if (rawVerdict === 'WARN' || rawVerdict === 'WARNING') {
+            verdict = 'WARNING';
+            status = 'WARNING';
         }
-        else if (rawVerdict === "STOP" || rawVerdict === "BLOCK" || rawVerdict === "ERROR") {
-            verdict = "BLOCK";
-            status = "ERROR";
+        else if (rawVerdict === 'STOP' || rawVerdict === 'BLOCK' || rawVerdict === 'ERROR') {
+            verdict = 'BLOCK';
+            status = 'ERROR';
         }
         // Extract risk tags from rationale, filtering to valid tags only
         const rationale = Array.isArray(parsed.rationale) ? parsed.rationale : [];
         const riskTags = rationale
-            .filter((r) => r && typeof r.code === "string")
-            .map((r) => r.code)
+            .filter((r) => r && typeof r.code === 'string')
+            .map(r => r.code)
             .filter((code) => VALID_RISK_TAGS.includes(code));
         // Build reason from rationale messages
         const reason = rationale
-            .filter((r) => r && typeof r.message === "string")
-            .map((r) => r.message)
-            .join("; ") || "Native inference result";
+            .filter((r) => r && typeof r.message === 'string')
+            .map(r => r.message)
+            .join('; ') || 'Native inference result';
         return {
             status,
             verdict,
@@ -118,7 +111,7 @@ async function runNativeCheck(files, context) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        console.error(`[BitNet Native] Error: ${msg}`);
+        logger.error(`[BitNet Native] Error: ${msg}`);
         return null;
     }
 }
@@ -128,27 +121,27 @@ async function runNativeCheck(files, context) {
 function sendJson(res, status, obj) {
     const body = JSON.stringify(obj, null, 2);
     res.statusCode = status;
-    res.setHeader("Content-Type", "application/json; charset=utf-8");
-    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.setHeader('Access-Control-Allow-Origin', '*');
     res.end(body);
 }
 function readRequestBody(req, maxBytes) {
     return new Promise((resolve, reject) => {
         let total = 0;
         const chunks = [];
-        req.on("data", (chunk) => {
+        req.on('data', (chunk) => {
             total += chunk.length;
             if (total > maxBytes) {
-                reject(new Error("body_too_large"));
+                reject(new Error('body_too_large'));
                 req.destroy();
                 return;
             }
             chunks.push(chunk);
         });
-        req.on("end", () => {
-            resolve(Buffer.concat(chunks).toString("utf-8"));
+        req.on('end', () => {
+            resolve(Buffer.concat(chunks).toString('utf-8'));
         });
-        req.on("error", (err) => reject(err));
+        req.on('error', err => reject(err));
     });
 }
 function parseJson(body) {
@@ -168,17 +161,12 @@ async function handleHealth(_req, res) {
     metrics.queueLen = queueStats.free.active + queueStats.paid.active;
     // Build native inference status
     const nativeEnabled = isNativeInferenceEnabled();
-    const serverModeEnabled = isServerModeEnabled();
     const nativeInference = getNativeInference();
     const nativeStatus = {
         enabled: nativeEnabled,
         available: nativeInference.isAvailable(),
-        serverMode: serverModeEnabled,
+        serverMode: false,
     };
-    if (serverModeEnabled) {
-        const serverManager = getServerManager();
-        nativeStatus.serverStatus = serverManager.getStatus();
-    }
     const response = {
         ok: true,
         model_loaded: true, // Always true for rule-based engine
@@ -202,19 +190,21 @@ async function handleCheck(req, res, maxBodyBytes) {
         const body = await readRequestBody(req, maxBodyBytes);
         const input = parseJson(body);
         if (!input) {
-            sendJson(res, 400, { ok: false, error: "invalid_json" });
+            sendJson(res, 400, { ok: false, error: 'invalid_json' });
             return;
         }
         const files = Array.isArray(input.files) ? [...input.files].map(String).sort() : undefined;
-        const context = typeof input.context === "string" ? input.context : undefined;
-        const key = sha256Json({ t: "check", files: files ?? [], context: context ?? "" });
+        const context = typeof input.context === 'string' ? input.context : undefined;
+        // Enrich context from Block Store chains for native inference path
+        const enrichedContext = enrichContextFromChains(process.cwd(), files ?? [], context ?? '');
+        const key = sha256Json({ t: 'check', files: files ?? [], context: context ?? '' });
         const { value: result, cacheHit } = await checkCache.runDedupe(key, async () => {
             return await tieredQueue.run(async () => {
                 const queueStats = tieredQueue.getStats();
                 metrics.queueLen = queueStats.free.active + queueStats.paid.active;
-                // Use native inference if enabled
+                // Use native inference if enabled (with chain-enriched context)
                 if (isNativeInferenceEnabled()) {
-                    const nativeResult = await runNativeCheck(files, context);
+                    const nativeResult = await runNativeCheck(files, enrichedContext);
                     if (nativeResult) {
                         return nativeResult;
                     }
@@ -233,7 +223,7 @@ async function handleCheck(req, res, maxBodyBytes) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        sendJson(res, 500, { ok: false, error: "check_failed", message: msg });
+        sendJson(res, 500, { ok: false, error: 'check_failed', message: msg });
     }
 }
 async function handleSignal(req, res, maxBodyBytes) {
@@ -250,11 +240,11 @@ async function handleSignal(req, res, maxBodyBytes) {
         const body = await readRequestBody(req, maxBodyBytes);
         const input = parseJson(body);
         if (!input) {
-            sendJson(res, 400, { ok: false, error: "invalid_json" });
+            sendJson(res, 400, { ok: false, error: 'invalid_json' });
             return;
         }
         const includeAutopilot = !!input.include_autopilot;
-        const key = sha256Json({ t: "signal", include_autopilot: includeAutopilot });
+        const key = sha256Json({ t: 'signal', include_autopilot: includeAutopilot });
         const { value: result, cacheHit } = await signalCache.runDedupe(key, async () => {
             return await tieredQueue.run(async () => {
                 const queueStats = tieredQueue.getStats();
@@ -272,7 +262,7 @@ async function handleSignal(req, res, maxBodyBytes) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        sendJson(res, 500, { ok: false, error: "signal_failed", message: msg });
+        sendJson(res, 500, { ok: false, error: 'signal_failed', message: msg });
     }
 }
 async function handleTrace(_req, res, traceId) {
@@ -285,7 +275,7 @@ async function handleTrace(_req, res, traceId) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        sendJson(res, 500, { ok: false, error: "trace_failed", message: msg });
+        sendJson(res, 500, { ok: false, error: 'trace_failed', message: msg });
     }
 }
 // ============================================================
@@ -303,7 +293,7 @@ function fnv1a32Embed(input) {
     return h >>> 0;
 }
 function generateCharNgrams(text, minN, maxN) {
-    const normalized = text.toLowerCase().replace(/\r\n/g, "\n");
+    const normalized = text.toLowerCase().replace(/\r\n/g, '\n');
     const ngrams = [];
     for (let n = minN; n <= maxN; n++) {
         for (let i = 0; i <= normalized.length - n; i++) {
@@ -315,21 +305,46 @@ function generateCharNgrams(text, minN, maxN) {
 function tokenizeForEmbed(text) {
     const tokens = text
         .toLowerCase()
-        .replace(/[^\p{L}\p{N}_\s-]+/gu, " ")
+        .replace(/[^\p{L}\p{N}_\s-]+/gu, ' ')
         .split(/\s+/)
-        .map((t) => t.trim())
+        .map(t => t.trim())
         .filter(Boolean);
     const stop = new Set([
-        "the", "a", "an", "and", "or", "to", "of", "in", "on", "for", "with", "as", "by", "from",
-        "is", "are", "was", "were", "be", "been", "being", "have", "has", "had", "do", "does", "did",
+        'the',
+        'a',
+        'an',
+        'and',
+        'or',
+        'to',
+        'of',
+        'in',
+        'on',
+        'for',
+        'with',
+        'as',
+        'by',
+        'from',
+        'is',
+        'are',
+        'was',
+        'were',
+        'be',
+        'been',
+        'being',
+        'have',
+        'has',
+        'had',
+        'do',
+        'does',
+        'did',
     ]);
-    return tokens.filter((t) => t.length >= 2 && !stop.has(t));
+    return tokens.filter(t => t.length >= 2 && !stop.has(t));
 }
 function generateWordNgrams(tokens, minN, maxN) {
     const ngrams = [];
     for (let n = minN; n <= maxN; n++) {
         for (let i = 0; i <= tokens.length - n; i++) {
-            ngrams.push(tokens.slice(i, i + n).join("_"));
+            ngrams.push(tokens.slice(i, i + n).join('_'));
         }
     }
     return ngrams;
@@ -373,12 +388,16 @@ async function handleEmbed(req, res, maxBodyBytes) {
         const body = await readRequestBody(req, maxBodyBytes);
         const input = parseJson(body);
         if (!input || !Array.isArray(input.texts)) {
-            sendJson(res, 400, { ok: false, error: "invalid_json", message: "texts array required" });
+            sendJson(res, 400, {
+                ok: false,
+                error: 'invalid_json',
+                message: 'texts array required',
+            });
             return;
         }
         const batchSize = input.batch_size ?? 16;
         const embeddings = [];
-        let model = "ngram-fallback";
+        let model = 'ngram-fallback';
         // Process texts in batches
         for (let i = 0; i < input.texts.length; i += batchSize) {
             const batch = input.texts.slice(i, i + batchSize);
@@ -395,7 +414,7 @@ async function handleEmbed(req, res, maxBodyBytes) {
                             const numbers = result.output.trim().split(/\s+/).map(Number);
                             if (numbers.length === EMBED_DIM && !numbers.some(isNaN)) {
                                 embeddings.push(numbers);
-                                model = "bitnet-native";
+                                model = 'bitnet-native';
                                 continue;
                             }
                         }
@@ -420,20 +439,20 @@ async function handleEmbed(req, res, maxBodyBytes) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        sendJson(res, 500, { ok: false, error: "embed_failed", message: msg });
+        sendJson(res, 500, { ok: false, error: 'embed_failed', message: msg });
     }
 }
 // ============================================================
 // Server
 // ============================================================
 export function startBitNetWorkerServer(opts = {}) {
-    const host = opts.host ?? process.env.VIBE_BITNET_WORKER_HOST ?? "127.0.0.1";
+    const host = opts.host ?? process.env.VIBE_BITNET_WORKER_HOST ?? '127.0.0.1';
     const port = opts.port ?? Number(process.env.VIBE_BITNET_WORKER_PORT || 8844);
     const maxBodyBytes = opts.maxBodyBytes ?? 2_000_000; // 2MB
     // K8s health probe handlers
     const handleLiveness = createLivenessHandler({
         version: process.env.npm_package_version,
-        component: "bitnet-worker",
+        component: 'bitnet-worker',
     });
     const handleReadiness = createReadinessHandler([
         modelLoadedChecker(() => {
@@ -448,93 +467,90 @@ export function startBitNetWorkerServer(opts = {}) {
     ]);
     const server = http.createServer(async (req, res) => {
         // CORS preflight
-        if (req.method === "OPTIONS") {
+        if (req.method === 'OPTIONS') {
             res.statusCode = 204;
-            res.setHeader("Access-Control-Allow-Origin", "*");
-            res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-User-Tier");
-            res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-User-Tier');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
             res.end();
             return;
         }
-        const url = new URL(req.url ?? "/", `http://${req.headers.host || "localhost"}`);
+        const url = new URL(req.url ?? '/', `http://${req.headers.host || 'localhost'}`);
         // GET /healthz - K8s liveness probe
-        if (req.method === "GET" && url.pathname === "/healthz") {
+        if (req.method === 'GET' && url.pathname === '/healthz') {
             handleLiveness(req, res);
             return;
         }
         // GET /readyz - K8s readiness probe
-        if (req.method === "GET" && url.pathname === "/readyz") {
+        if (req.method === 'GET' && url.pathname === '/readyz') {
             await handleReadiness(req, res);
             return;
         }
         // GET /health (legacy)
-        if (req.method === "GET" && url.pathname === "/health") {
+        if (req.method === 'GET' && url.pathname === '/health') {
             await handleHealth(req, res);
             return;
         }
         // POST /check
-        if (req.method === "POST" && url.pathname === "/check") {
+        if (req.method === 'POST' && url.pathname === '/check') {
             await handleCheck(req, res, maxBodyBytes);
             return;
         }
         // POST /signal
-        if (req.method === "POST" && url.pathname === "/signal") {
+        if (req.method === 'POST' && url.pathname === '/signal') {
             await handleSignal(req, res, maxBodyBytes);
             return;
         }
         // POST /embed
-        if (req.method === "POST" && url.pathname === "/embed") {
+        if (req.method === 'POST' && url.pathname === '/embed') {
             await handleEmbed(req, res, maxBodyBytes);
             return;
         }
         // GET /trace or GET /trace/:id
-        if (req.method === "GET" && url.pathname.startsWith("/trace")) {
-            const parts = url.pathname.split("/").filter(Boolean);
+        if (req.method === 'GET' && url.pathname.startsWith('/trace')) {
+            const parts = url.pathname.split('/').filter(Boolean);
             const traceId = parts.length > 1 ? decodeURIComponent(parts[1]) : undefined;
             await handleTrace(req, res, traceId);
             return;
         }
         // 404
-        sendJson(res, 404, { ok: false, error: "not_found" });
+        sendJson(res, 404, { ok: false, error: 'not_found' });
     });
     server.listen(port, host);
     const serverUrl = `http://${host}:${port}`;
-    console.log(`[BitNet Worker] Started on ${serverUrl}`);
+    logger.info(`[BitNet Worker] Started on ${serverUrl}`);
     logSlotLimits();
     logCpuStatus();
     // Log native inference status
     if (isNativeInferenceEnabled()) {
         const nativeInference = getNativeInference();
         const config = nativeInference.getConfig();
-        console.log(`[BitNet Worker] Native inference: ENABLED`);
-        console.log(`  Binary: ${config.binaryPath}`);
-        console.log(`  Model: ${config.modelPath}`);
-        console.log(`  Threads: ${config.threads}`);
-        console.log(`  Available: ${nativeInference.isAvailable()}`);
-        if (isServerModeEnabled()) {
-            console.log(`[BitNet Worker] Server mode: ENABLED`);
-            const serverManager = getServerManager();
-            const serverConfig = serverManager.getConfig();
-            console.log(`  Server: ${serverConfig.serverPath}`);
-            console.log(`  Port: ${serverConfig.port}`);
-            // Start server in background
-            ensureServerRunning()
-                .then(() => {
-                console.log(`[BitNet Worker] Native server started on port ${serverConfig.port}`);
-            })
-                .catch((err) => {
-                console.error(`[BitNet Worker] Failed to start native server: ${err.message}`);
-            });
-        }
+        logger.info(`[BitNet Worker] Native inference: ENABLED`);
+        logger.info(`  Binary: ${config.binaryPath}`);
+        logger.info(`  Model: ${config.modelPath}`);
+        logger.info(`  Threads: ${config.threads}`);
+        logger.info(`  Available: ${nativeInference.isAvailable()}`);
+        // Initialize BitNet manager
+        const serverManager = getServerManager();
+        const serverConfig = serverManager.getConfig();
+        logger.info(`  Binary: ${serverConfig.binaryPath}`);
+        // Start manager in background
+        ensureServerRunning()
+            .then(() => {
+            logger.info(`[BitNet Worker] Native inference ready`);
+        })
+            .catch(err => {
+            logger.error(`[BitNet Worker] Failed to initialize: ${err.message}`);
+        });
     }
     else {
-        console.log(`[BitNet Worker] Native inference: DISABLED (rule-based mode)`);
+        logger.info(`[BitNet Worker] Native inference: DISABLED (rule-based mode)`);
     }
     return {
         server,
         url: serverUrl,
         close: () => new Promise((resolve, reject) => {
-            server.close((err) => {
+            server.close(err => {
                 if (err)
                     reject(err);
                 else

package/build/bitnet-worker/server_manager.d.ts

@@ -1,52 +1,37 @@
 /**
- * LlamaServer Manager
- * ===================
+ * BitNet Inference Manager
+ * ========================
  *
- * Manages a persistent llama-server daemon for fast inference.
- * Eliminates cold start time (~5min → <1sec) by keeping the model loaded.
+ * Uses bitnet.cpp for true 1.58-bit optimized inference.
  *
- * Benefits:
- * - Cold start: 5min+ → <1sec
- * - No repeated model loading
- * - HTTP API for inference
- * - Graceful shutdown support
+ * Performance (vs PyTorch):
+ * - Memory: 10GB → 1.7GB (6x reduction)
+ * - Speed: 2 t/s → 20+ t/s (10x improvement)
  *
  * Environment variables:
- *   VIBE_BITNET_SERVER_MODE   - Enable server mode ('1' to enable)
- *   VIBE_BITNET_SERVER        - Path to server binary
+ *   VIBE_BITNET_BINARY        - Path to bitnet.cpp CLI binary
  *   VIBE_BITNET_MODEL         - Path to GGUF model
  *   VIBE_BITNET_THREADS       - CPU thread count
- *   VIBE_BITNET_SERVER_PORT   - Server port (default: 8081)
  *   VIBE_BITNET_CONTEXT       - Context window size (default: 2048)
  *
  * @module bitnet-worker/server_manager
  */
-import { EventEmitter } from "node:events";
-export interface LlamaServerConfig {
-    /** Path to llama-server binary */
-    serverPath: string;
+import { EventEmitter } from 'node:events';
+export interface BitNetConfig {
+    /** Path to bitnet.cpp CLI binary */
+    binaryPath: string;
     /** Path to GGUF model file */
     modelPath: string;
-    /** Server port */
-    port: number;
     /** Number of CPU threads */
     threads: number;
     /** Context window size */
     contextSize: number;
-    /** GPU layers (0 for CPU only) */
-    gpuLayers: number;
-    /** Startup timeout in milliseconds */
-    startupTimeoutMs: number;
     /** Request timeout in milliseconds */
     requestTimeoutMs: number;
 }
 export interface ServerStatus {
-    /** Whether server is ready to accept requests */
+    /** Whether manager is ready to accept requests */
     ready: boolean;
-    /** Server port */
-    port: number;
-    /** Process ID if running */
-    pid?: number;
     /** Uptime in milliseconds */
     uptimeMs?: number;
     /** Last error message */
@@ -62,72 +47,61 @@ export interface CompletionRequest {
 export interface CompletionResponse {
     content: string;
     stop: boolean;
-    generation_settings?: Record<string, unknown>;
     timings?: {
         predicted_ms: number;
         predicted_n: number;
         predicted_per_token_ms: number;
     };
 }
-export declare class LlamaServerManager extends EventEmitter {
+export declare class BitNetManager extends EventEmitter {
     private config;
-    private process;
     private ready;
     private startTime;
     private lastError;
-    private healthCheckInterval;
-    constructor(config?: Partial<LlamaServerConfig>);
+    constructor(config?: Partial<BitNetConfig>);
     /**
-     * Check if server binary and model exist
+     * Check if binary and model exist
      */
     isAvailable(): boolean;
     /**
-     * Get current server status
+     * Get current status
      */
     getStatus(): ServerStatus;
     /**
      * Get configuration
      */
-    getConfig(): LlamaServerConfig;
+    getConfig(): BitNetConfig;
     /**
-     * Start the llama-server daemon
+     * Initialize the manager (verify binary/model exist)
      */
     start(): Promise<void>;
     /**
-     * Stop the llama-server daemon
+     * Reset the manager
      */
     stop(): Promise<void>;
     /**
-     * Restart the server
+     * Restart
      */
     restart(): Promise<void>;
     /**
-     * Send a completion request to the server
+     * Run inference using bitnet.cpp CLI
      */
     complete(request: CompletionRequest): Promise<CompletionResponse>;
     /**
-     * Convenience method for simple inference
+     * Simple inference method
      */
     infer(prompt: string): Promise<string>;
     /**
-     * Check server health
+     * Check if binary/model still exist
      */
     health(): Promise<boolean>;
-    private setReady;
-    private waitForReady;
-    private startHealthCheck;
-    private stopHealthCheck;
-    private sleep;
 }
+export { BitNetManager as LlamaServerManager };
 /**
- * Get or create the singleton LlamaServerManager instance
+ * Get or create the singleton BitNetManager instance
  */
-export declare function getServerManager(): LlamaServerManager;
+export declare function getServerManager(): BitNetManager;
 /**
- * Check if server mode is enabled via environment variable
+ * Ensure manager is initialized
  */
-export declare function isServerModeEnabled(): boolean;
-/**
- * Ensure server is running (start if needed)
- */
-export declare function ensureServerRunning(): Promise<LlamaServerManager>;
+export declare function ensureServerRunning(): Promise<BitNetManager>;