feat: complete JS rewrite - Transformers.js + Node.js + Mission Barisal Checker

README.md

@@ -1,14 +1,63 @@
 ---
-title: Sahon
-emoji: 👀
+title: Sahon AI
+emoji: 🤖
 colorFrom: purple
 colorTo: green
-sdk: gradio
-sdk_version: 6.20.0
+sdk: nodejs
+sdk_version: 22
 python_version: '3.12'
-app_file: app.py
+app_file: app.js
 pinned: false
-short_description: Machine Learning
+short_description: Transformers.js AI with Mission Barisal Checker
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Sahon AI 🤖
+
+**Pure JavaScript LLM Inference** using `@huggingface/transformers` (Transformers.js).
+
+- **Model:** `Xenova/phi-3-mini-4k-instruct` (April 2024 | 3.8B params)
+- **Engine:** Transformers.js via ONNX Runtime
+- **Checker:** Mission Barisal Response Validation
+- **Zero Python!** Everything runs in Node.js
+
+## API Endpoints (OpenAI-Compatible)
+
+| Endpoint | Method | Description |
+|---|---|---|
+| `/v1/models` | GET | List available models |
+| `/v1/chat/completions` | POST | Chat completions |
+| `/v1/completions` | POST | Text completions |
+| `/health` | GET | Health check |
+
+### Usage
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://bdzombie-sahon.hf.space/v1",
+    api_key="not-needed"
+)
+
+response = client.chat.completions.create(
+    model="phi-3-mini-4k-instruct",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+print(response.choices[0].message.content)
+```
+
+## Mission Barisal Checker
+
+Every response is validated for:
+- **Bias detection** — neutral language analysis
+- **Hallucination check** — hedging/uncertainty detection
+- **Quality scoring** — overall response quality metric
+
+Results appear in API responses under `_mission_barisal` field.
+
+## Tech Stack
+
+- `@huggingface/transformers` — Transformers.js v3
+- `express` — Web server
+- ONNX Runtime (WASM) — Model inference
+- Phi-3 Mini 4K Instruct — Microsoft, April 2024

app.js

@@ -0,0 +1,400 @@
+/**
+ * Sahon AI - Transformers.js Server
+ * ==================================
+ * Pure JavaScript LLM inference with OpenAI-compatible API
+ * and Mission Barisal Response Checker
+ */
+
+import { pipeline } from '@huggingface/transformers';
+import express from 'express';
+import cors from 'cors';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import fs from 'fs';
+
+// ─── Config ───
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PORT = parseInt(process.env.PORT || '7860');
+const HOST = '0.0.0.0';
+
+// Use Phi-3-mini-4k-instruct (April 2024, pre-converted ONNX)
+// Fits user's timeframe: mid-2024, real model (not agent)
+const MODEL_ID = 'Xenova/phi-3-mini-4k-instruct';
+
+// ─── State ───
+let generator = null;
+let modelReady = false;
+let modelError = null;
+let modelProgress = 'Initializing...';
+
+// ─── Mission Barisal Checker Module ───
+// Validates model outputs for bias, hallucination, and quality
+const missionBarisalChecker = {
+  /**
+   * Check response for potential bias
+   * @param {string} question - Original question
+   * @param {string} response - Model's response
+   * @returns {{biased: boolean, reasons: string[]}}
+   */
+  checkBias(question, response) {
+    const reasons = [];
+    const lowerQ = question.toLowerCase();
+    const lowerR = response.toLowerCase();
+
+    // Check for neutral language
+    const strongWords = ['always', 'never', 'everyone', 'nobody', 'definitely', 'absolutely', 'undoubtedly'];
+    const foundStrong = strongWords.filter(w => lowerR.includes(w));
+    if (foundStrong.length > 0) {
+      reasons.push(`Uses absolute language: ${foundStrong.join(', ')}`);
+    }
+
+    // Check for balanced perspective on debatable topics
+    const debatableMarkers = ['however', 'on the other hand', 'alternatively', 'some argue', 'critics say'];
+    const hasBalance = debatableMarkers.some(m => lowerR.includes(m));
+    if (!hasBalance && question.length > 20) {
+      // Longer questions might need more balanced answers
+      // This is a soft check
+    }
+
+    return {
+      biased: foundStrong.length > 2,
+      reasons,
+      score: Math.max(0, 1 - (foundStrong.length * 0.1))
+    };
+  },
+
+  /**
+   * Check for potential hallucination signs
+   * @param {string} response
+   * @returns {{risk: 'low'|'medium'|'high', indicators: string[]}}
+   */
+  checkHallucination(response) {
+    const indicators = [];
+    const lowerR = response.toLowerCase();
+
+    // Check for hedging language (might indicate uncertainty)
+    const certaintyPhrases = ['i think', 'i believe', 'maybe', 'perhaps', 'possibly', 'might be', 'could be'];
+    const foundHedging = certaintyPhrases.filter(p => lowerR.includes(p));
+    if (foundHedging.length > 0) {
+      indicators.push(`Shows uncertainty: ${foundHedging.join(', ')}`);
+    }
+
+    // Check for specific claims without qualifiers
+    const specificClaims = (response.match(/\d{4}/g) || []);  // Years
+    if (specificClaims.length > 3) {
+      indicators.push(`Multiple date/year claims: ${specificClaims.join(', ')}`);
+    }
+
+    // Length-based risk indicator
+    const words = response.split(/\s+/).length;
+    let risk = 'low';
+    if (words > 500 && foundHedging.length > 2) risk = 'medium';
+    if (words > 1000 && foundHedging.length > 3) risk = 'high';
+
+    return { risk, indicators };
+  },
+
+  /**
+   * Validate complete response quality
+   * @param {string} question
+   * @param {string} response
+   * @returns {{passed: boolean, checks: object, overall: number}}
+   */
+  validate(question, response) {
+    if (!response || response.trim().length === 0) {
+      return { passed: false, checks: { empty: true }, overall: 0 };
+    }
+
+    const biasCheck = this.checkBias(question, response);
+    const hallucinationCheck = this.checkHallucination(response);
+
+    // Calculate overall score (0-1)
+    const hasContent = Math.min(1, response.length / 100);
+    const biasScore = biasCheck.score;
+    const halScore = hallucinationCheck.risk === 'low' ? 1 :
+                     hallucinationCheck.risk === 'medium' ? 0.7 : 0.4;
+
+    const overall = (hasContent * 0.3 + biasScore * 0.35 + halScore * 0.35);
+
+    return {
+      passed: overall > 0.5,
+      checks: {
+        bias: biasCheck,
+        hallucination: hallucinationCheck,
+        length: response.split(/\s+/).length
+      },
+      overall: Math.round(overall * 100) / 100
+    };
+  }
+};
+
+// ─── Model Loading ───
+async function initModel() {
+  try {
+    modelProgress = 'Loading model...';
+    console.log(`[Sahon] Loading model: ${MODEL_ID}`);
+
+    // Create text-generation pipeline
+    generator = await pipeline('text-generation', MODEL_ID, {
+      dtype: 'q4',        // 4-bit quantization for speed
+      device: 'cpu',       // CPU inference
+      progress_callback: (progress) => {
+        if (progress.status === 'progress') {
+          modelProgress = `Downloading: ${Math.round(progress.progress * 100)}%`;
+          console.log(`[Sahon] ${modelProgress}`);
+        }
+      }
+    });
+
+    modelReady = true;
+    modelProgress = 'Ready';
+    console.log('[Sahon] Model loaded successfully!');
+  } catch (err) {
+    modelError = err.message;
+    modelProgress = `Error: ${err.message}`;
+    console.error('[Sahon] Model loading failed:', err);
+  }
+}
+
+// Start loading immediately
+initModel();
+
+// ─── Express App ───
+const app = express();
+app.use(cors());
+app.use(express.json());
+app.use(express.static(join(__dirname, 'public')));
+
+// ─── Middleware: Check model readiness ───
+app.use('/v1/', (req, res, next) => {
+  if (!modelReady) {
+    return res.status(503).json({
+      error: 'Model is still loading',
+      status: modelProgress,
+      error_detail: modelError
+    });
+  }
+  next();
+});
+
+// ─── OpenAI-Compatible API ───
+
+// GET /v1/models
+app.get('/v1/models', (req, res) => {
+  res.json({
+    object: 'list',
+    data: [{
+      id: 'phi-3-mini-4k-instruct',
+      object: 'model',
+      created: Math.floor(Date.now() / 1000),
+      owned_by: 'mission-barisal'
+    }]
+  });
+});
+
+// POST /v1/chat/completions
+app.post('/v1/chat/completions', async (req, res) => {
+  const { model, messages = [], temperature = 0.7, max_tokens = 512, stream = false } = req.body;
+
+  // Convert OpenAI-format messages to prompt
+  const prompt = buildPrompt(messages);
+
+  if (stream) {
+    // Streaming response
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    });
+
+    try {
+      const fullResponse = [];
+      // Generate with streaming
+      const result = await generator(prompt, {
+        max_new_tokens: max_tokens,
+        temperature: temperature,
+        do_sample: temperature > 0,
+        return_full_text: false,
+      });
+
+      const text = result[0]?.generated_text?.trim() || '';
+      fullResponse.push(text);
+
+      // Send in chunks
+      const chunkSize = 10;
+      for (let i = 0; i < text.length; i += chunkSize) {
+        const chunk = text.slice(i, i + chunkSize);
+        const sseData = {
+          id: `chatcmpl-${Date.now()}`,
+          object: 'chat.completion.chunk',
+          created: Math.floor(Date.now() / 1000),
+          model: model || 'phi-3-mini-4k-instruct',
+          choices: [{
+            index: 0,
+            delta: { content: chunk },
+            finish_reason: null
+          }]
+        };
+        res.write(`data: ${JSON.stringify(sseData)}\n\n`);
+        await new Promise(r => setTimeout(r, 30)); // Simulate streaming
+      }
+
+      // Done
+      const doneData = {
+        id: `chatcmpl-${Date.now()}`,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model: model || 'phi-3-mini-4k-instruct',
+        choices: [{
+          index: 0,
+          delta: {},
+          finish_reason: 'stop'
+        }]
+      };
+      res.write(`data: ${JSON.stringify(doneData)}\n\n`);
+      res.write('data: [DONE]\n\n');
+      res.end();
+    } catch (err) {
+      res.write(`data: ${JSON.stringify({ error: err.message })}\n\n`);
+      res.end();
+    }
+  } else {
+    // Non-streaming response
+    try {
+      const result = await generator(prompt, {
+        max_new_tokens: max_tokens,
+        temperature: temperature,
+        do_sample: temperature > 0,
+        return_full_text: false,
+      });
+
+      const text = result[0]?.generated_text?.trim() || '';
+
+      // ─── Mission Barisal Check ───
+      const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
+      const question = lastUserMsg?.content || '';
+      const checkResult = missionBarisalChecker.validate(question, text);
+
+      const response = {
+        id: `chatcmpl-${Date.now()}`,
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: model || 'phi-3-mini-4k-instruct',
+        choices: [{
+          index: 0,
+          message: {
+            role: 'assistant',
+            content: text,
+          },
+          finish_reason: 'stop',
+        }],
+        usage: {
+          prompt_tokens: Math.ceil(prompt.length / 4),
+          completion_tokens: Math.ceil(text.length / 4),
+          total_tokens: Math.ceil((prompt.length + text.length) / 4),
+        },
+        // ─── Mission Barisal Metadata ───
+        _mission_barisal: {
+          checked: true,
+          quality_score: checkResult.overall,
+          passed: checkResult.passed,
+          checks: checkResult.checks
+        }
+      };
+
+      res.json(response);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+});
+
+// POST /v1/completions
+app.post('/v1/completions', async (req, res) => {
+  const { model, prompt: inputPrompt, temperature = 0.7, max_tokens = 512 } = req.body;
+
+  try {
+    const result = await generator(inputPrompt, {
+      max_new_tokens: max_tokens,
+      temperature: temperature,
+      do_sample: temperature > 0,
+      return_full_text: false,
+    });
+
+    const text = result[0]?.generated_text?.trim() || '';
+
+    res.json({
+      id: `cmpl-${Date.now()}`,
+      object: 'text_completion',
+      created: Math.floor(Date.now() / 1000),
+      model: model || 'phi-3-mini-4k-instruct',
+      choices: [{
+        index: 0,
+        text: text,
+        finish_reason: 'stop',
+      }],
+      usage: {
+        prompt_tokens: Math.ceil(inputPrompt.length / 4),
+        completion_tokens: Math.ceil(text.length / 4),
+        total_tokens: Math.ceil((inputPrompt.length + text.length) / 4),
+      }
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ─── Health Check ───
+app.get('/health', (req, res) => {
+  res.json({
+    status: modelReady ? 'ok' : 'loading',
+    model: MODEL_ID,
+    model_ready: modelReady,
+    progress: modelProgress,
+    error: modelError,
+    mission_barisal: {
+      checker_version: '1.0.0',
+      agent: 'code-guru-monu',
+      last_check: new Date().toISOString()
+    }
+  });
+});
+
+// ─── Start Server ───
+app.listen(PORT, HOST, () => {
+  console.log(`\n╔══════════════════════════════════════════════╗`);
+  console.log(`║     Sahon AI - Transformers.js Server       ║`);
+  console.log(`╠══════════════════════════════════════════════╣`);
+  console.log(`║  Model: ${MODEL_ID.padEnd(35)}║`);
+  console.log(`║  Port:  ${String(PORT).padEnd(36)}║`);
+  console.log(`║  Status: ${(modelReady ? 'READY' : 'Loading...').padEnd(33)}║`);
+  console.log(`╠══════════════════════════════════════════════╣`);
+  console.log(`║  Chat UI  : http://${HOST}:${PORT}/        ║`);
+  console.log(`║  API      : http://${HOST}:${PORT}/v1/chat/completions ║`);
+  console.log(`║  Health   : http://${HOST}:${PORT}/health   ║`);
+  console.log(`╚══════════════════════════════════════════════╝\n`);
+});
+
+// ─── Helper: Build prompt from messages ───
+function buildPrompt(messages) {
+  // Phi-3 format: <|system|>\n...<|end|>\n<|user|>\n...<|end|>\n<|assistant|>\n
+  let prompt = '';
+  for (const msg of messages) {
+    switch (msg.role) {
+      case 'system':
+        prompt += `<|system|>\n${msg.content}<|end|>\n`;
+        break;
+      case 'user':
+        prompt += `<|user|>\n${msg.content}<|end|>\n`;
+        break;
+      case 'assistant':
+        prompt += `<|assistant|>\n${msg.content}<|end|>\n`;
+        break;
+      default:
+        prompt += `<|user|>\n${msg.content}<|end|>\n`;
+    }
+  }
+  prompt += '<|assistant|>\n';
+  return prompt;
+}

app.py

@@ -1,375 +0,0 @@
-#!/usr/bin/env python3
-"""
-Sahon AI - Llama 3.2 3B Instruct Uncensored
-============================================
-Hugging Face Space with:
-  - Gradio Chat UI (at /)
-  - OpenAI-compatible REST API (at /v1/chat/completions)
-  - Model downloaded from bartowski/Llama-3.2-3B-Instruct-uncensored-GGUF
-  - Powered by llama-cpp-python (CPU inference)
-"""
-
-import os
-import json
-import time
-import threading
-from typing import Optional, List
-
-# ==================== CONFIGURATION ====================
-MODEL_REPO_ID = "bartowski/Llama-3.2-3B-Instruct-uncensored-GGUF"
-MODEL_FILENAME = "Llama-3.2-3B-Instruct-uncensored-Q6_K.gguf"
-MODEL_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), MODEL_FILENAME)
-HOST = "0.0.0.0"
-PORT = int(os.environ.get("PORT", 7860))
-MAX_TOKENS = 2048
-TEMPERATURE = 0.7
-N_CTX = 4096
-
-# Global model state
-llm = None
-model_ready = False
-model_error: Optional[str] = None
-model_progress = "Initializing..."
-
-# ==================== MODEL MANAGEMENT ====================
-
-def download_model() -> str:
-    """Download the GGUF model from Hugging Face Hub."""
-    global model_progress
-    from huggingface_hub import hf_hub_download
-
-    model_progress = "Downloading model (~2.3 GB)..."
-    print(f"[Sahon] {model_progress}")
-    print(f"[Sahon]   Repo: {MODEL_REPO_ID}")
-    print(f"[Sahon]   File: {MODEL_FILENAME}")
-
-    local_path = hf_hub_download(
-        repo_id=MODEL_REPO_ID,
-        filename=MODEL_FILENAME,
-        local_dir=os.path.dirname(os.path.abspath(__file__)),
-        local_dir_use_symlinks=False,
-        resume_download=True,
-    )
-
-    size_gb = os.path.getsize(local_path) / (1024**3)
-    print(f"[Sahon] Model downloaded: {local_path} ({size_gb:.2f} GB)")
-    return local_path
-
-
-def load_model(model_path: str):
-    """Load the GGUF model with llama-cpp-python."""
-    global llm, model_progress
-    from llama_cpp import Llama
-
-    model_progress = "Loading model into memory (this may take 30-60s)..."
-    print(f"[Sahon] {model_progress}")
-
-    llm = Llama(
-        model_path=model_path,
-        n_ctx=N_CTX,
-        n_threads=os.cpu_count() or 4,
-        n_gpu_layers=0,     # CPU-only inference
-        verbose=False,
-    )
-
-    print("[Sahon] Model loaded successfully!")
-
-
-def init_model():
-    """Initialize model in background thread."""
-    global model_ready, model_error, model_progress
-
-    try:
-        model_progress = "Checking if model exists locally..."
-        path = MODEL_PATH
-
-        if not os.path.exists(path):
-            path = download_model()
-        else:
-            size_gb = os.path.getsize(path) / (1024**3)
-            print(f"[Sahon] Model already cached ({size_gb:.2f} GB)")
-
-        load_model(path)
-        model_ready = True
-        model_progress = "Ready"
-        print("[Sahon] === Model is READY ===")
-
-    except Exception as e:
-        model_error = str(e)
-        model_progress = f"Error: {e}"
-        print(f"[Sahon] Model initialization FAILED: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-# Kick off model loading immediately (background thread)
-print("[Sahon] Starting model initialization in background thread...")
-threading.Thread(target=init_model, daemon=True).start()
-
-
-# ==================== FASTAPI APP (OpenAI API) ====================
-
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse, StreamingResponse
-from pydantic import BaseModel, Field
-
-# ── FastAPI app ──
-app = FastAPI(title="Sahon AI API")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# ── Request / Response models ──
-class ChatMessage(BaseModel):
-    role: str
-    content: str
-
-class ChatCompletionRequest(BaseModel):
-    model: str = "Llama-3.2-3B-Instruct-uncensored"
-    messages: List[ChatMessage]
-    temperature: Optional[float] = TEMPERATURE
-    max_tokens: Optional[int] = MAX_TOKENS
-    stream: Optional[bool] = False
-
-class CompletionRequest(BaseModel):
-    model: str = "Llama-3.2-3B-Instruct-uncensored"
-    prompt: str
-    max_tokens: Optional[int] = MAX_TOKENS
-    temperature: Optional[float] = TEMPERATURE
-    stream: Optional[bool] = False
-
-
-# ── Middleware: return 503 until model is ready ──
-@app.middleware("http")
-async def check_model_ready_mw(request: Request, call_next):
-    if request.url.path.startswith("/v1/") or request.url.path.startswith("/health"):
-        if not model_ready:
-            status = 503
-            body = {"error": f"Model not ready yet. Status: {model_progress}"}
-            if model_error:
-                body = {"error": f"Model failed: {model_error}"}
-            return JSONResponse(status_code=status, content=body)
-    return await call_next(request)
-
-
-# ── GET /v1/models ──
-@app.get("/v1/models")
-async def list_models():
-    return {
-        "object": "list",
-        "data": [{
-            "id": "Llama-3.2-3B-Instruct-uncensored",
-            "object": "model",
-            "created": int(time.time()),
-            "owned_by": "bdzombie",
-        }]
-    }
-
-
-# ── POST /v1/chat/completions ──
-@app.post("/v1/chat/completions")
-async def chat_completions(req: ChatCompletionRequest):
-    if req.stream:
-        return StreamingResponse(
-            _stream_chat(req),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no",
-            },
-        )
-
-    messages = [m.model_dump() for m in req.messages]
-    try:
-        response = llm.create_chat_completion(
-            messages=messages,
-            max_tokens=req.max_tokens or MAX_TOKENS,
-            temperature=req.temperature or TEMPERATURE,
-        )
-        return response
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-def _stream_chat(req: ChatCompletionRequest):
-    """Generator for streaming chat completions."""
-    messages = [m.model_dump() for m in req.messages]
-    try:
-        stream = llm.create_chat_completion(
-            messages=messages,
-            max_tokens=req.max_tokens or MAX_TOKENS,
-            temperature=req.temperature or TEMPERATURE,
-            stream=True,
-        )
-        for chunk in stream:
-            yield f"data: {json.dumps(chunk)}\n\n"
-        yield "data: [DONE]\n\n"
-    except Exception as e:
-        yield f"data: {json.dumps({'error': str(e)})}\n\n"
-
-
-# ── POST /v1/completions ──
-@app.post("/v1/completions")
-async def completions(req: CompletionRequest):
-    try:
-        response = llm.create_completion(
-            prompt=req.prompt,
-            max_tokens=req.max_tokens or MAX_TOKENS,
-            temperature=req.temperature or TEMPERATURE,
-            stream=req.stream,
-        )
-        if req.stream:
-            return StreamingResponse(
-                (f"data: {json.dumps(chunk)}\n\n" for chunk in response),
-                media_type="text/event-stream",
-            )
-        return response
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ── GET /health ──
-@app.get("/health")
-async def health():
-    return {
-        "status": "ok" if model_ready else "loading",
-        "model_ready": model_ready,
-        "progress": model_progress,
-        "error": model_error,
-    }
-
-
-# ==================== GRADIO CHAT UI ====================
-
-import gradio as gr
-
-
-def gradio_chat(message: str, history: List[List[str]]) -> str:
-    """Chat function for Gradio ChatInterface."""
-    if not model_ready:
-        if model_error:
-            return f"Model failed to load: {model_error}"
-        return f"Model is loading... Status: {model_progress}"
-
-    # Build message list from history
-    messages: List[dict] = []
-    for user_msg, assistant_msg in history:
-        messages.append({"role": "user", "content": user_msg})
-        if assistant_msg:
-            messages.append({"role": "assistant", "content": assistant_msg})
-    messages.append({"role": "user", "content": message})
-
-    try:
-        response = llm.create_chat_completion(
-            messages=messages,
-            max_tokens=MAX_TOKENS,
-            temperature=TEMPERATURE,
-        )
-        return response["choices"][0]["message"]["content"]
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-def get_status_text() -> str:
-    """Return current status as emoji + text."""
-    if model_ready:
-        return "Ready"
-    elif model_error:
-        return f"Error: {model_error}"
-    else:
-        return model_progress
-
-
-# Build Gradio Blocks interface
-with gr.Blocks(
-    title="Sahon AI - Llama 3.2 Uncensored",
-    theme=gr.themes.Soft(),
-) as demo:
-    gr.Markdown(
-        """
-        # Sahon AI
-        ### Llama 3.2 3B Instruct Uncensored (Q6_K)
-
-        **Powered by llama-cpp-python** — CPU-only inference
-        """
-    )
-
-    with gr.Row():
-        status_btn = gr.Button("Refresh Status")
-        status_box = gr.Textbox(
-            value=get_status_text(),
-            label="Model Status",
-            interactive=False,
-        )
-
-    def refresh():
-        return get_status_text()
-
-    status_btn.click(fn=refresh, outputs=status_box)
-
-    # Auto-refresh status every 5 seconds
-    demo.load(fn=refresh, outputs=status_box, every=5)
-
-    with gr.Accordion("API Endpoints (OpenAI-Compatible)", open=False):
-        gr.Markdown(
-            """
-            **Base URL:** `https://bdzombie-sahon.hf.space`
-
-            | Endpoint | Method | Description |
-            |---|---|---|
-            | `/v1/models` | GET | List models |
-            | `/v1/chat/completions` | POST | Chat completions |
-            | `/v1/completions` | POST | Text completions |
-
-            **Python example:**
-            ```python
-            from openai import OpenAI
-
-            client = OpenAI(
-                base_url="https://bdzombie-sahon.hf.space/v1",
-                api_key="any",   # not used
-            )
-
-            response = client.chat.completions.create(
-                model="Llama-3.2-3B-Instruct-uncensored",
-                messages=[{"role": "user", "content": "Hello!"}]
-            )
-            print(response.choices[0].message.content)
-            ```
-            """
-        )
-
-    gr.Markdown("---")
-
-    gr.ChatInterface(
-        fn=gradio_chat,
-        title="Chat with Llama 3.2",
-        description="Uncensored model — use responsibly.",
-        examples=[
-            "What is the capital of Bangladesh?",
-            "Explain quantum computing in simple terms.",
-            "Write a Python function to check if a string is a palindrome.",
-        ],
-    )
-
-
-# ==================== MOUNT GRADIO ON FASTAPI ====================
-
-app = gr.mount_gradio_app(app, demo, path="/")
-
-
-# ==================== MAIN ====================
-
-if __name__ == "__main__":
-    import uvicorn
-    print(f"[Sahon] Starting server on {HOST}:{PORT}")
-    print(f"[Sahon]   Chat UI : http://{HOST}:{PORT}/")
-    print(f"[Sahon]   API     : http://{HOST}:{PORT}/v1/chat/completions")
-    uvicorn.run(app, host=HOST, port=PORT, log_level="info")

package.json

@@ -0,0 +1,15 @@
+{
+  "name": "sahon-ai",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Sahon AI - Transformers.js with Mission Barisal Checker",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3.4.0",
+    "express": "^5.1.0",
+    "cors": "^2.8.5"
+  }
+}

public/index.html

@@ -0,0 +1,224 @@
+<!DOCTYPE html>
+<html lang="bn">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Sahon AI - Transformers.js</title>
+  <style>
+    :root { --primary: #6c5ce7; --bg: #0a0a1a; --card: #1a1a2e; --text: #eee; --muted: #888; }
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: system-ui, sans-serif; background: var(--bg); color: var(--text); min-height: 100vh; }
+    .container { max-width: 800px; margin: 0 auto; padding: 20px; }
+    header { text-align: center; padding: 20px 0; }
+    header h1 { font-size: 1.8em; background: linear-gradient(135deg, #6c5ce7, #a29bfe); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+    header p { color: var(--muted); margin-top: 5px; font-size: 0.9em; }
+    .status-bar { background: var(--card); border-radius: 12px; padding: 12px 20px; margin: 15px 0; display: flex; align-items: center; gap: 10px; }
+    .status-dot { width: 10px; height: 10px; border-radius: 50%; background: #f39c12; flex-shrink: 0; }
+    .status-dot.ready { background: #2ecc71; }
+    .status-dot.error { background: #e74c3c; }
+    .chat-container { background: var(--card); border-radius: 12px; overflow: hidden; }
+    .messages { height: 400px; overflow-y: auto; padding: 20px; display: flex; flex-direction: column; gap: 12px; }
+    .msg { max-width: 80%; padding: 12px 16px; border-radius: 12px; line-height: 1.5; font-size: 0.95em; }
+    .msg.user { background: var(--primary); align-self: flex-end; border-bottom-right-radius: 4px; }
+    .msg.assistant { background: #2d2d4a; align-self: flex-start; border-bottom-left-radius: 4px; }
+    .msg.system { background: #1a1a2e; align-self: center; font-style: italic; color: var(--muted); font-size: 0.85em; border: 1px solid #333; }
+    .msg .meta { font-size: 0.7em; color: var(--muted); margin-top: 4px; }
+    .quality-badge { display: inline-block; padding: 2px 8px; border-radius: 10px; font-size: 0.75em; margin-top: 4px; }
+    .quality-high { background: #27ae6033; color: #2ecc71; }
+    .quality-medium { background: #f39c1233; color: #f1c40f; }
+    .quality-low { background: #e74c3c33; color: #e74c3c; }
+    .input-area { display: flex; padding: 15px; gap: 10px; border-top: 1px solid #333; }
+    .input-area input { flex: 1; padding: 12px 16px; border-radius: 8px; border: 1px solid #333; background: #0a0a1a; color: var(--text); font-size: 0.95em; outline: none; }
+    .input-area input:focus { border-color: var(--primary); }
+    .input-area button { padding: 12px 24px; border-radius: 8px; border: none; background: var(--primary); color: white; font-weight: 600; cursor: pointer; transition: 0.2s; }
+    .input-area button:hover { background: #5a4bd1; }
+    .input-area button:disabled { opacity: 0.5; cursor: not-allowed; }
+    .examples { display: flex; gap: 8px; flex-wrap: wrap; padding: 10px 15px; }
+    .examples button { padding: 6px 12px; border-radius: 15px; border: 1px solid #333; background: transparent; color: var(--muted); font-size: 0.85em; cursor: pointer; transition: 0.2s; }
+    .examples button:hover { border-color: var(--primary); color: var(--text); }
+    .api-info { background: var(--card); border-radius: 12px; padding: 20px; margin-top: 20px; }
+    .api-info h3 { margin-bottom: 10px; color: var(--primary); }
+    .api-info code { display: block; background: #0a0a1a; padding: 12px; border-radius: 8px; font-size: 0.85em; margin: 5px 0; white-space: pre-wrap; }
+    footer { text-align: center; padding: 20px; color: var(--muted); font-size: 0.8em; }
+    .thinking { display: flex; gap: 4px; align-items: center; padding: 12px 16px; }
+    .thinking span { width: 8px; height: 8px; background: var(--muted); border-radius: 50%; animation: bounce 1.4s infinite ease-in-out both; }
+    .thinking span:nth-child(1) { animation-delay: -0.32s; }
+    .thinking span:nth-child(2) { animation-delay: -0.16s; }
+    @keyframes bounce { 0%, 80%, 100% { transform: scale(0); } 40% { transform: scale(1); } }
+    @media (max-width: 600px) { .container { padding: 10px; } .msg { max-width: 90%; } }
+  </style>
+</head>
+<body>
+<div class="container">
+  <header>
+    <h1>🤖 Sahon AI</h1>
+    <p>Phi-3 Mini 4K Instruct · Transformers.js · Mission Barisal Checker</p>
+  </header>
+
+  <div class="status-bar" id="statusBar">
+    <div class="status-dot" id="statusDot"></div>
+    <span id="statusText">Connecting...</span>
+  </div>
+
+  <div class="chat-container">
+    <div class="messages" id="messages">
+      <div class="msg system">👋 Welcome! Model is loading. Ask me anything once ready.</div>
+    </div>
+    <div class="examples" id="examples">
+      <button onclick="askExample('বাংলাদেশের রাজধানী কোথায়?')">🇧🇩 বাংলাদেশ</button>
+      <button onclick="askExample('Explain quantum computing simply')">⚛️ Quantum</button>
+      <button onclick="askExample('Write a Python prime function')">🐍 Code</button>
+      <button onclick="askExample('AI vs Human Intelligence')">🧠 AI vs Human</button>
+    </div>
+    <div class="input-area">
+      <input type="text" id="input" placeholder="Type your message..." disabled>
+      <button id="sendBtn" onclick="sendMessage()" disabled>Send</button>
+    </div>
+  </div>
+
+  <div class="api-info">
+    <h3>🔌 API Endpoints (OpenAI-Compatible)</h3>
+    <p>Use with any OpenAI client:</p>
+    <code>from openai import OpenAI
+client = OpenAI(
+    base_url="https://bdzombie-sahon.hf.space/v1",
+    api_key="not-needed"
+)
+response = client.chat.completions.create(
+    model="phi-3-mini-4k-instruct",
+    messages=[{"role": "user", "content": "Hello!"}]
+)</code>
+    <p style="margin-top:10px;color:var(--muted);font-size:0.85em;">
+      ✅ GET /v1/models · ✅ POST /v1/chat/completions · ✅ POST /v1/completions · ✅ GET /health
+    </p>
+  </div>
+
+  <footer>
+    Mission Barisal · Code Guru Monu · Transformers.js<br>
+    <span style="font-size:0.8em;color:#555;">No Python. Pure JavaScript. 🚀</span>
+  </footer>
+</div>
+
+<script>
+let isReady = false;
+
+// Check health
+async function checkHealth() {
+  try {
+    const res = await fetch('/health');
+    const data = await res.json();
+    const dot = document.getElementById('statusDot');
+    const text = document.getElementById('statusText');
+
+    if (data.model_ready) {
+      isReady = true;
+      dot.className = 'status-dot ready';
+      text.textContent = '��� Ready — Model loaded';
+      document.getElementById('input').disabled = false;
+      document.getElementById('sendBtn').disabled = false;
+      addSystemMsg('✅ Model is ready! Ask me anything.');
+    } else {
+      dot.className = 'status-dot';
+      text.textContent = `⏳ ${data.progress || 'Loading...'}`;
+      setTimeout(checkHealth, 3000);
+    }
+  } catch (e) {
+    document.getElementById('statusText').textContent = '⏳ Connecting to server...';
+    setTimeout(checkHealth, 3000);
+  }
+}
+checkHealth();
+
+function addSystemMsg(text) {
+  const msgs = document.getElementById('messages');
+  const div = document.createElement('div');
+  div.className = 'msg system';
+  div.textContent = text;
+  msgs.appendChild(div);
+  msgs.scrollTop = msgs.scrollHeight;
+}
+
+function addMsg(role, content, meta = '') {
+  const msgs = document.getElementById('messages');
+  const div = document.createElement('div');
+  div.className = `msg ${role}`;
+  div.innerHTML = `<div>${content}</div>`;
+  if (meta) {
+    div.innerHTML += `<div class="meta">${meta}</div>`;
+  }
+  msgs.appendChild(div);
+  msgs.scrollTop = msgs.scrollHeight;
+}
+
+function showThinking() {
+  const msgs = document.getElementById('messages');
+  const div = document.createElement('div');
+  div.className = 'msg assistant';
+  div.id = 'thinking';
+  div.innerHTML = '<div class="thinking"><span></span><span></span><span></span></div>';
+  msgs.appendChild(div);
+  msgs.scrollTop = msgs.scrollHeight;
+}
+
+function removeThinking() {
+  const el = document.getElementById('thinking');
+  if (el) el.remove();
+}
+
+async function sendMessage() {
+  const input = document.getElementById('input');
+  const msg = input.value.trim();
+  if (!msg || !isReady) return;
+
+  input.value = '';
+  addMsg('user', msg);
+  showThinking();
+
+  try {
+    const res = await fetch('/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'phi-3-mini-4k-instruct',
+        messages: [{ role: 'user', content: msg }],
+        temperature: 0.7,
+        max_tokens: 512
+      })
+    });
+    const data = await res.json();
+    removeThinking();
+
+    let responseText = data.choices?.[0]?.message?.content || 'No response';
+    let metaHtml = '';
+
+    // Show Mission Barisal check results if available
+    if (data._mission_barisal) {
+      const mb = data._mission_barisal;
+      const quality = mb.quality_score;
+      const badgeClass = quality > 0.7 ? 'quality-high' : quality > 0.4 ? 'quality-medium' : 'quality-low';
+      const badgeLabel = quality > 0.7 ? '✅ Passed' : quality > 0.4 ? '⚠️ Review' : '❌ Failed';
+      metaHtml = `
+        <span class="quality-badge ${badgeClass}">${badgeLabel} (${Math.round(quality * 100)}%)</span>
+        <span style="margin-left:8px;font-size:0.75em;color:#888;">Mission Barisal Checked ✓</span>
+      `;
+    }
+
+    addMsg('assistant', responseText, metaHtml);
+  } catch (err) {
+    removeThinking();
+    addMsg('system', 'Error: ' + err.message);
+  }
+}
+
+function askExample(text) {
+  document.getElementById('input').value = text;
+  sendMessage();
+}
+
+// Send on Enter
+document.getElementById('input').addEventListener('keydown', (e) => {
+  if (e.key === 'Enter') sendMessage();
+});
+</script>
+</body>
+</html>

requirements.txt

@@ -1,7 +0,0 @@
-gradio>=5.0.0
-llama-cpp-python>=0.2.0
-huggingface_hub>=0.20.0
-fastapi>=0.100.0
-uvicorn[standard]>=0.20.0
-pydantic>=2.0.0
-sse-starlette>=1.0.0