@bao826078/chatai 0.0.0-stage → 0.2.0

package/dist/server.js

@@ -0,0 +1,973 @@
+import express from "express";
+import dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+import { GoogleGenAI } from "@google/genai";
+import { dbManager } from "./server/db.ts";
+dotenv.config();
+await dbManager.init();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const app = express();
+function resolvePort() {
+  const args = process.argv;
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "--port" || args[i] === "-p") && args[i + 1]) {
+      const p = Number(args[i + 1]);
+      if (!isNaN(p) && p > 0) return p;
+    }
+    if (args[i].startsWith("--port=")) {
+      const p = Number(args[i].split("=")[1]);
+      if (!isNaN(p) && p > 0) return p;
+    }
+  }
+  if (process.env.PORT) {
+    const p = Number(process.env.PORT);
+    if (!isNaN(p) && p > 0) return p;
+  }
+  return 8088;
+}
+const PRIMARY_PORT = resolvePort();
+app.use(express.json({ limit: "10mb" }));
+app.use(express.urlencoded({ extended: true, limit: "10mb" }));
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
+const DEFAULT_9ROUTER_BASE_URL = "https://api.9router.com/v1";
+function getGoogleAIClient(customApiKey) {
+  const apiKey = customApiKey && customApiKey.trim().length > 0 ? customApiKey.trim() : process.env.GEMINI_API_KEY;
+  if (!apiKey || apiKey === "MY_GEMINI_API_KEY") {
+    const err = new Error("No API Key provided. Please enter a valid API Key to proceed.");
+    err.code = "MISSING_API_KEY";
+    throw err;
+  }
+  return new GoogleGenAI({
+    apiKey,
+    httpOptions: {
+      headers: {
+        "User-Agent": "aistudio-build"
+      }
+    }
+  });
+}
+function classifyError(error) {
+  const rawMsg = (error?.message || "").toLowerCase();
+  const status = error?.status || error?.statusCode;
+  if (rawMsg.includes("api_key_invalid") || rawMsg.includes("api key not valid") || rawMsg.includes("api key expired") || rawMsg.includes("unauthenticated") || rawMsg.includes("permission_denied") || rawMsg.includes("authentication_error") || rawMsg.includes("invalid_api_key") || rawMsg.includes("invalid x-api-key") || rawMsg.includes("key has expired") || rawMsg.includes("invalid api key") || rawMsg.includes("invalid_argument") || rawMsg.includes("incorrect api key") || status === 400 || status === 401 || status === 403) {
+    return {
+      isApiKeyError: true,
+      friendlyMessage: "Kh\xF3a API kh\xF4ng h\u1EE3p l\u1EC7 ho\u1EB7c \u0111\xE3 h\u1EBFt h\u1EA1n. Vui l\xF2ng ki\u1EC3m tra v\xE0 c\u1EADp nh\u1EADt l\u1EA1i API Key m\u1EDBi \u0111\u1EC3 ti\u1EBFp t\u1EE5c."
+    };
+  }
+  if (rawMsg.includes("resource_exhausted") || rawMsg.includes("quota") || rawMsg.includes("rate limit") || status === 429) {
+    return {
+      isApiKeyError: true,
+      friendlyMessage: "Kh\xF3a API \u0111\xE3 v\u01B0\u1EE3t qu\xE1 h\u1EA1n m\u1EE9c s\u1EED d\u1EE5ng (Quota / Rate Limit). Vui l\xF2ng th\u1EED l\u1EA1i sau ho\u1EB7c \u0111\u1ED5i kh\xF3a kh\xE1c."
+    };
+  }
+  if (rawMsg.includes("not_found") || rawMsg.includes("404") || rawMsg.includes("no longer available") || status === 404) {
+    return {
+      isApiKeyError: false,
+      friendlyMessage: "M\xF4 h\xECnh n\xE0y hi\u1EC7n kh\xF4ng kh\u1EA3 d\u1EE5ng ho\u1EB7c \u0111\xE3 ng\u1EEBng h\u1ED7 tr\u1EE3. H\u1EC7 th\u1ED1ng khuy\u1EBFn ngh\u1ECB ch\u1ECDn m\xF4 h\xECnh ho\u1EA1t \u0111\u1ED9ng nh\u01B0 gemini-3.8-flash."
+    };
+  }
+  return {
+    isApiKeyError: false,
+    friendlyMessage: error?.message || "\u0110\xE3 x\u1EA3y ra l\u1ED7i khi k\u1EBFt n\u1ED1i v\u1EDBi m\xE1y ch\u1EE7 AI."
+  };
+}
+app.get("/api/config", (_req, res) => {
+  const hasValidDefault = Boolean(
+    process.env.GEMINI_API_KEY && process.env.GEMINI_API_KEY.trim().length > 0 && process.env.GEMINI_API_KEY !== "MY_GEMINI_API_KEY"
+  );
+  console.log(`[Config] Serving configuration (hasDefaultKey: ${hasValidDefault})`);
+  res.json({
+    hasDefaultApiKey: hasValidDefault,
+    defaultOpenAiUrl: DEFAULT_OPENAI_BASE_URL,
+    defaultAnthropicUrl: DEFAULT_ANTHROPIC_BASE_URL,
+    default9RouterUrl: DEFAULT_9ROUTER_BASE_URL,
+    serverTime: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+function getTargetBaseUrl(provider, baseUrl) {
+  if (baseUrl && baseUrl.trim().length > 0) {
+    return baseUrl.trim().replace(/\/+$/, "");
+  }
+  if (provider === "openai") return DEFAULT_OPENAI_BASE_URL;
+  if (provider === "claude") return DEFAULT_ANTHROPIC_BASE_URL;
+  if (provider === "9router") return DEFAULT_9ROUTER_BASE_URL;
+  return "";
+}
+app.post("/api/models", async (req, res) => {
+  try {
+    const { apiKey, provider = "openai", baseUrl } = req.body;
+    const activeKey = apiKey && typeof apiKey === "string" ? apiKey.trim() : "";
+    if (!activeKey) {
+      console.log(`[Models] No API key provided for provider "${provider}". Returning empty list.`);
+      return res.json({
+        ok: true,
+        models: [],
+        count: 0,
+        message: "Ch\u01B0a c\xF3 API Key. Vui l\xF2ng nh\u1EADp API Key \u0111\u1EC3 nh\u1EADn danh s\xE1ch m\xF4 h\xECnh t\u1EEB nh\xE0 cung c\u1EA5p."
+      });
+    }
+    console.log(`[Models] Fetching live models from API for provider: "${provider}"...`);
+    if (provider === "google") {
+      const googleUrl = `https://generativelanguage.googleapis.com/v1beta/models?key=${activeKey}`;
+      const response2 = await fetch(googleUrl);
+      if (!response2.ok) {
+        const errText = await response2.text();
+        console.warn(`[Models] Failed to fetch Google models (HTTP ${response2.status}): ${errText.slice(0, 100)}`);
+        return res.json({
+          ok: false,
+          models: [],
+          error: `Kh\xF3a Google API kh\xF4ng h\u1EE3p l\u1EC7 ho\u1EB7c \u0111\xE3 h\u1EBFt h\u1EA1n (M\xE3 l\u1ED7i: ${response2.status}).`
+        });
+      }
+      const data2 = await response2.json();
+      const rawList2 = Array.isArray(data2?.models) ? data2.models : [];
+      const deprecatedModels = [
+        "gemini-2.5-flash",
+        "gemini-2.5-pro",
+        "gemini-2.0-flash",
+        "gemini-2.0-pro",
+        "gemini-1.5-flash",
+        "gemini-1.5-pro",
+        "gemini-1.0-pro"
+      ];
+      const nonTextKeywords = ["tts", "image", "embedding", "transcribe", "robotics"];
+      const supportedModels = rawList2.filter((m) => {
+        const id = (m.name || "").replace(/^models\//, "").toLowerCase();
+        const methods = Array.isArray(m.supportedGenerationMethods) ? m.supportedGenerationMethods : [];
+        if (!methods.includes("generateContent")) return false;
+        if (deprecatedModels.includes(id)) return false;
+        if (nonTextKeywords.some((kw) => id.includes(kw))) return false;
+        return true;
+      });
+      const priorityOrder = [
+        "gemini-3.8-flash",
+        "gemini-3.7-flash",
+        "gemini-3.6-flash",
+        "gemini-3.5-flash",
+        "gemini-flash-latest",
+        "gemini-3.1-flash-lite",
+        "gemini-flash-lite-latest",
+        "gemini-pro-latest",
+        "gemini-2.5-flash-lite",
+        "gemini-4-argon"
+      ];
+      supportedModels.sort((a, b) => {
+        const idA = (a.name || "").replace(/^models\//, "").toLowerCase();
+        const idB = (b.name || "").replace(/^models\//, "").toLowerCase();
+        const idxA = priorityOrder.findIndex((p) => idA.startsWith(p));
+        const idxB = priorityOrder.findIndex((p) => idB.startsWith(p));
+        if (idxA !== -1 && idxB !== -1) return idxA - idxB;
+        if (idxA !== -1) return -1;
+        if (idxB !== -1) return 1;
+        return idA.localeCompare(idB);
+      });
+      const mapped = supportedModels.map((m) => {
+        const id = (m.name || "").replace(/^models\//, "");
+        return {
+          id,
+          name: m.displayName || id,
+          badge: "Google",
+          description: m.description || `M\xF4 h\xECnh Google AI: ${id}`,
+          provider: "google"
+        };
+      });
+      console.log(`[Models] Successfully retrieved ${mapped.length} live models from Google API.`);
+      return res.json({
+        ok: true,
+        models: mapped,
+        count: mapped.length
+      });
+    }
+    if (provider === "claude") {
+      const cleanBase2 = getTargetBaseUrl("claude", baseUrl);
+      const response2 = await fetch(`${cleanBase2}/models`, {
+        headers: {
+          "x-api-key": activeKey,
+          "anthropic-version": "2023-06-01"
+        }
+      });
+      if (!response2.ok) {
+        const errText = await response2.text();
+        console.warn(`[Models] Failed to fetch Claude models (HTTP ${response2.status}): ${errText.slice(0, 100)}`);
+        return res.json({
+          ok: false,
+          models: [],
+          error: `Kh\xF3a API Claude kh\xF4ng h\u1EE3p l\u1EC7 ho\u1EB7c kh\xF4ng c\xF3 quy\u1EC1n truy c\u1EADp (M\xE3 l\u1ED7i: ${response2.status}).`
+        });
+      }
+      const data2 = await response2.json();
+      const rawList2 = Array.isArray(data2?.data) ? data2.data : [];
+      const mapped = rawList2.map((m) => ({
+        id: m.id,
+        name: m.display_name || m.id,
+        badge: "Claude",
+        description: `M\xF4 h\xECnh Anthropic Claude: ${m.display_name || m.id}`,
+        provider: "claude"
+      }));
+      console.log(`[Models] Successfully retrieved ${mapped.length} live models from Anthropic API.`);
+      return res.json({
+        ok: true,
+        models: mapped,
+        count: mapped.length
+      });
+    }
+    const cleanBase = getTargetBaseUrl(provider, baseUrl) || (provider === "9router" ? DEFAULT_9ROUTER_BASE_URL : DEFAULT_OPENAI_BASE_URL);
+    const response = await fetch(`${cleanBase}/models`, {
+      headers: {
+        Authorization: `Bearer ${activeKey}`
+      }
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      console.warn(`[Models] Failed to fetch models for "${provider}" (HTTP ${response.status}): ${errText.slice(0, 100)}`);
+      return res.json({
+        ok: false,
+        models: [],
+        error: `Kh\xF4ng th\u1EC3 l\u1EA5y danh s\xE1ch m\xF4 h\xECnh t\u1EEB nh\xE0 cung c\u1EA5p (M\xE3 l\u1ED7i: ${response.status}). Vui l\xF2ng ki\u1EC3m tra l\u1EA1i API Key ho\u1EB7c URL.`
+      });
+    }
+    const data = await response.json();
+    const rawList = Array.isArray(data?.data) ? data.data : Array.isArray(data) ? data : [];
+    let filteredList = rawList;
+    if (provider === "openai") {
+      const nonChatKeywords = ["whisper", "tts", "embedding", "moderation", "dall-e", "davinci", "babbage", "curie", "realtime"];
+      filteredList = rawList.filter((m) => {
+        const id = (typeof m === "string" ? m : m.id || "").toLowerCase();
+        return !nonChatKeywords.some((kw) => id.includes(kw));
+      });
+      const priorityOrder = ["gpt-4o", "gpt-4o-mini", "o1", "o3-mini", "o1-mini", "chatgpt-4o-latest", "gpt-4.5", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"];
+      filteredList.sort((a, b) => {
+        const idA = (typeof a === "string" ? a : a.id || "").toLowerCase();
+        const idB = (typeof b === "string" ? b : b.id || "").toLowerCase();
+        const indexA = priorityOrder.findIndex((p) => idA.startsWith(p));
+        const indexB = priorityOrder.findIndex((p) => idB.startsWith(p));
+        if (indexA !== -1 && indexB !== -1) return indexA - indexB;
+        if (indexA !== -1) return -1;
+        if (indexB !== -1) return 1;
+        return idA.localeCompare(idB);
+      });
+    }
+    const badgeLabel = provider === "openai" ? "OpenAI" : provider === "9router" ? "9Router" : "AI Cung C\u1EA5p";
+    const mappedModels = filteredList.map((m) => {
+      const id = typeof m === "string" ? m : m.id || m.name;
+      return {
+        id,
+        name: id,
+        badge: badgeLabel,
+        description: m.description || `M\xF4 h\xECnh AI: ${id}`,
+        provider
+      };
+    });
+    console.log(`[Models] Successfully retrieved ${mappedModels.length} live models for provider "${provider}".`);
+    return res.json({
+      ok: true,
+      models: mappedModels,
+      count: mappedModels.length
+    });
+  } catch (error) {
+    console.error(`[Models] Unexpected error fetching models:`, error?.message);
+    return res.json({
+      ok: false,
+      models: [],
+      error: error?.message || "L\u1ED7i khi t\u1EA3i danh s\xE1ch m\xF4 h\xECnh t\u1EEB m\xE1y ch\u1EE7."
+    });
+  }
+});
+app.post("/api/verify-key", async (req, res) => {
+  try {
+    const { apiKey, provider = "openai", baseUrl } = req.body;
+    const keyToTest = apiKey && typeof apiKey === "string" ? apiKey.trim() : "";
+    if (!keyToTest) {
+      return res.json({
+        ok: false,
+        errorType: "INVALID_OR_EXPIRED_KEY",
+        error: "Vui l\xF2ng nh\u1EADp m\xE3 API Key \u0111\u1EC3 ki\u1EC3m tra k\u1EBFt n\u1ED1i."
+      });
+    }
+    console.log(`[Verify] Verifying credentials for provider: "${provider}"...`);
+    if (provider === "google") {
+      const googleUrl = `https://generativelanguage.googleapis.com/v1beta/models?key=${keyToTest}`;
+      const response2 = await fetch(googleUrl);
+      if (response2.ok) {
+        const data = await response2.json();
+        const count = Array.isArray(data?.models) ? data.models.length : 0;
+        console.log(`[Verify] Google API key verification passed (found ${count} models).`);
+        return res.json({
+          ok: true,
+          message: `K\u1EBFt n\u1ED1i th\xE0nh c\xF4ng v\u1EDBi Google AI Studio! \u0110\xE3 x\xE1c th\u1EF1c kh\xF3a API (t\xECm th\u1EA5y ${count} m\xF4 h\xECnh kh\u1EA3 d\u1EE5ng).`
+        });
+      } else {
+        console.warn(`[Verify] Google API key verification failed with status: ${response2.status}`);
+        return res.json({
+          ok: false,
+          errorType: "INVALID_OR_EXPIRED_KEY",
+          error: `Kh\xF3a Google API kh\xF4ng h\u1EE3p l\u1EC7 (M\xE3 ph\u1EA3n h\u1ED3i: ${response2.status}).`
+        });
+      }
+    }
+    if (provider === "claude") {
+      const cleanBase2 = getTargetBaseUrl("claude", baseUrl);
+      const response2 = await fetch(`${cleanBase2}/models`, {
+        headers: {
+          "x-api-key": keyToTest,
+          "anthropic-version": "2023-06-01"
+        }
+      });
+      if (response2.ok) {
+        console.log("[Verify] Anthropic Claude API key verification passed.");
+        return res.json({
+          ok: true,
+          message: "K\u1EBFt n\u1ED1i th\xE0nh c\xF4ng v\u1EDBi Anthropic Claude! Kh\xF3a API c\u1EE7a b\u1EA1n ho\u1EA1t \u0111\u1ED9ng b\xECnh th\u01B0\u1EDDng."
+        });
+      } else {
+        const errText = await response2.text();
+        console.warn(`[Verify] Anthropic Claude verification failed with status: ${response2.status}`);
+        return res.json({
+          ok: false,
+          errorType: "INVALID_OR_EXPIRED_KEY",
+          error: `Kh\xF3a API Claude kh\xF4ng h\u1EE3p l\u1EC7 (M\xE3: ${response2.status}). ${errText.slice(0, 80)}`
+        });
+      }
+    }
+    const cleanBase = getTargetBaseUrl(provider, baseUrl) || (provider === "9router" ? DEFAULT_9ROUTER_BASE_URL : DEFAULT_OPENAI_BASE_URL);
+    const response = await fetch(`${cleanBase}/models`, {
+      headers: {
+        Authorization: `Bearer ${keyToTest}`
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      const count = Array.isArray(data?.data) ? data.data.length : 0;
+      const providerLabel = provider === "openai" ? "OpenAI" : provider === "9router" ? "9Router" : "m\xE1y ch\u1EE7 AI";
+      console.log(`[Verify] API key verification passed for "${providerLabel}" (found ${count} models).`);
+      return res.json({
+        ok: true,
+        message: `K\u1EBFt n\u1ED1i th\xE0nh c\xF4ng v\u1EDBi ${providerLabel}! Kh\xF3a API v\xE0 URL ho\u1EA1t \u0111\u1ED9ng b\xECnh th\u01B0\u1EDDng (T\xECm th\u1EA5y ${count} m\xF4 h\xECnh).`
+      });
+    } else {
+      const errText = await response.text();
+      console.warn(`[Verify] Verification failed for "${provider}" (HTTP ${response.status})`);
+      return res.json({
+        ok: false,
+        errorType: "INVALID_OR_EXPIRED_KEY",
+        error: `Kh\xF3a API ho\u1EB7c \u0111\u1ECBa ch\u1EC9 URL kh\xF4ng h\u1EE3p l\u1EC7 (M\xE3: ${response.status}). ${errText.slice(0, 80)}`
+      });
+    }
+  } catch (error) {
+    const { isApiKeyError, friendlyMessage } = classifyError(error);
+    console.error(`[Verify] Exception during key verification:`, error?.message);
+    return res.json({
+      ok: false,
+      errorType: isApiKeyError ? "INVALID_OR_EXPIRED_KEY" : "GENERAL_ERROR",
+      error: friendlyMessage
+    });
+  }
+});
+function estimateTextTokens(text) {
+  if (!text) return 0;
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return 0;
+  const hasCode = trimmed.includes("```") || trimmed.includes("{") || trimmed.includes("function") || trimmed.includes("const ");
+  const vietnameseRegex = /[àáạảãâầấậẩẫăằắặẳẵèéẹẻẽêềếệểễìíịỉĩòóọỏõôồốộổỗơờớợởỡùúụủũưừứựửữỳýỵỷỹđ]/i;
+  const isVietnamese = vietnameseRegex.test(trimmed);
+  if (hasCode) {
+    return Math.max(1, Math.ceil(trimmed.length / 3.2));
+  } else if (isVietnamese) {
+    const words = trimmed.split(/\s+/).filter(Boolean);
+    return Math.max(1, Math.ceil(words.length * 1.35) + Math.ceil(trimmed.length / 10));
+  } else {
+    const words = trimmed.split(/\s+/).filter(Boolean);
+    return Math.max(1, Math.ceil(words.length * 1.3));
+  }
+}
+app.get("/api/conversations", (_req, res) => {
+  try {
+    const list = dbManager.getConversations();
+    res.json({ ok: true, conversations: list });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.post("/api/conversations", (req, res) => {
+  try {
+    const { id, title, model, provider, system_instruction, user_id } = req.body;
+    const convId = id || "chat-" + Date.now();
+    const conv = dbManager.createConversation({
+      id: convId,
+      title,
+      model,
+      provider,
+      system_instruction,
+      user_id
+    });
+    res.json({ ok: true, conversation: conv });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.get("/api/conversations/:id", (req, res) => {
+  try {
+    const result = dbManager.getConversation(req.params.id);
+    if (!result) {
+      return res.status(404).json({ ok: false, error: "Conversation not found" });
+    }
+    res.json({ ok: true, ...result });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.put("/api/conversations/:id", (req, res) => {
+  try {
+    const { title, model, provider, system_instruction } = req.body;
+    const updated = dbManager.updateConversation(req.params.id, {
+      title,
+      model,
+      provider,
+      system_instruction
+    });
+    if (!updated) {
+      return res.status(404).json({ ok: false, error: "Conversation not found" });
+    }
+    res.json({ ok: true, conversation: updated });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.delete("/api/conversations/:id", (req, res) => {
+  try {
+    const success = dbManager.deleteConversation(req.params.id);
+    res.json({ ok: success });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.post("/api/conversations/:id/messages", (req, res) => {
+  try {
+    const { id, role, sender, content, metadata } = req.body;
+    const saved = dbManager.saveMessage({
+      id: id || "msg-" + Date.now(),
+      conversation_id: req.params.id,
+      role: role || "user",
+      sender: sender || "user",
+      content: content || "",
+      metadata
+    });
+    res.json({ ok: true, message: saved });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.post("/api/conversations/bulk-sync", (req, res) => {
+  try {
+    const { conversations = [] } = req.body;
+    let syncedConvs = 0;
+    let syncedMsgs = 0;
+    for (const c of conversations) {
+      if (!c.id) continue;
+      dbManager.createConversation({
+        id: c.id,
+        title: c.title,
+        model: c.model,
+        provider: c.provider,
+        system_instruction: c.systemInstruction,
+        created_at: c.createdAt ? new Date(c.createdAt).toISOString() : void 0,
+        updated_at: c.updatedAt ? new Date(c.updatedAt).toISOString() : void 0
+      });
+      syncedConvs++;
+      if (Array.isArray(c.messages)) {
+        for (const m of c.messages) {
+          if (!m.id || !m.content) continue;
+          dbManager.saveMessage({
+            id: m.id,
+            conversation_id: c.id,
+            role: m.role || (m.sender === "ai" ? "model" : "user"),
+            sender: m.sender || (m.role === "model" || m.role === "assistant" ? "ai" : "user"),
+            content: m.content,
+            created_at: m.timestamp ? new Date(m.timestamp).toISOString() : void 0,
+            metadata: {
+              modelUsed: m.modelUsed,
+              estimatedTokens: m.estimatedTokens
+            }
+          });
+          syncedMsgs++;
+        }
+      }
+    }
+    dbManager.persistNow();
+    res.json({ ok: true, syncedConvs, syncedMsgs });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.get("/api/analytics/monthly", (req, res) => {
+  try {
+    const month = typeof req.query.month === "string" ? req.query.month : void 0;
+    const stats = dbManager.getMonthlyAnalytics(month);
+    res.json({ ok: true, ...stats });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.get("/api/analytics/summary", (req, res) => {
+  try {
+    const count = Number(req.query.count) || 6;
+    const summary = dbManager.getRecentMonthsSummary(count);
+    res.json({ ok: true, summary });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.post("/api/analytics/record", (req, res) => {
+  try {
+    const record = dbManager.recordTokenUsage(req.body);
+    res.json({ ok: true, record });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+app.post("/api/chat/stream", async (req, res) => {
+  const {
+    messages = [],
+    model = "",
+    systemInstruction,
+    temperature = 0.7,
+    apiKey,
+    provider = "openai",
+    baseUrl,
+    conversationId,
+    userMessageId,
+    aiMessageId,
+    requestId
+  } = req.body;
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  res.flushHeaders?.();
+  const activeKey = apiKey && typeof apiKey === "string" ? apiKey.trim() : "";
+  if (!activeKey) {
+    console.warn(`[Stream] Chat stream rejected: Missing API key`);
+    res.write(
+      `data: ${JSON.stringify({
+        error: "Ch\u01B0a c\xF3 API Key. Vui l\xF2ng c\u1EA5u h\xECnh API Key trong m\u1EE5c C\xE0i \u0111\u1EB7t tr\u01B0\u1EDBc khi tr\xF2 chuy\u1EC7n.",
+        errorType: "INVALID_OR_EXPIRED_KEY"
+      })}
+
+`
+    );
+    res.write("data: [DONE]\n\n");
+    return res.end();
+  }
+  const rawModel = model || (provider === "google" ? "gemini-3.8-flash" : provider === "claude" ? "claude-3-5-sonnet-20241022" : "gpt-4o-mini");
+  let targetModel = String(rawModel).replace(/^models\//, "").trim();
+  if (provider === "google") {
+    const deprecated = ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.0-flash", "gemini-2.0-pro", "gemini-1.5-flash", "gemini-1.5-pro", "gemini-1.0-pro"];
+    if (deprecated.includes(targetModel.toLowerCase())) {
+      console.log(`[Stream] Migrating deprecated model "${targetModel}" to "gemini-3.8-flash"`);
+      targetModel = "gemini-3.8-flash";
+    }
+  }
+  console.log(`[Stream] Starting chat stream (provider: "${provider}", model: "${targetModel}", messageCount: ${messages.length})`);
+  const activeConvId = conversationId || "chat-" + Date.now();
+  const lastUserMsg = messages.filter((m) => m.role === "user" || m.sender === "user").slice(-1)[0];
+  const userText = lastUserMsg?.content || "";
+  try {
+    const existingConv = dbManager.getConversation(activeConvId);
+    if (!existingConv) {
+      dbManager.createConversation({
+        id: activeConvId,
+        title: userText ? userText.slice(0, 32) + (userText.length > 32 ? "..." : "") : "\u0110o\u1EA1n chat m\u1EDBi",
+        model: targetModel,
+        provider,
+        system_instruction: systemInstruction
+      });
+    }
+    if (userText && userMessageId) {
+      dbManager.saveMessage({
+        id: userMessageId,
+        conversation_id: activeConvId,
+        role: "user",
+        sender: "user",
+        content: userText
+      });
+    }
+  } catch (err) {
+    console.error("[Stream] Error initializing conversation in SQLite:", err);
+  }
+  const promptText = messages.map((m) => m.content || "").join("\n");
+  const fallbackInputTokens = estimateTextTokens(promptText);
+  let fullAiText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let totalTokens = 0;
+  let cachedTokens = 0;
+  let reasoningTokens = 0;
+  let usageSource = "estimated";
+  const finalizeAndSave = (status = "success") => {
+    if (usageSource === "estimated" || totalTokens === 0) {
+      inputTokens = inputTokens || fallbackInputTokens;
+      outputTokens = outputTokens || estimateTextTokens(fullAiText);
+      totalTokens = inputTokens + outputTokens;
+      usageSource = "estimated";
+    }
+    const aiMsgId = aiMessageId || "msg-" + Date.now() + "-ai";
+    try {
+      if (fullAiText.trim().length > 0) {
+        dbManager.saveMessage({
+          id: aiMsgId,
+          conversation_id: activeConvId,
+          role: "model",
+          sender: "ai",
+          content: fullAiText,
+          metadata: {
+            modelUsed: targetModel,
+            provider,
+            usageSource,
+            inputTokens,
+            outputTokens,
+            totalTokens
+          }
+        });
+      }
+      dbManager.recordTokenUsage({
+        conversation_id: activeConvId,
+        message_id: aiMsgId,
+        provider,
+        model: targetModel,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: totalTokens,
+        cached_input_tokens: cachedTokens,
+        reasoning_tokens: reasoningTokens,
+        usage_source: usageSource,
+        request_id: requestId || activeConvId + "-" + Date.now(),
+        status
+      });
+    } catch (saveErr) {
+      console.error("[Stream] Error saving to SQLite:", saveErr);
+    }
+    res.write(
+      `data: ${JSON.stringify({
+        usage: {
+          inputTokens,
+          outputTokens,
+          totalTokens,
+          cachedTokens,
+          reasoningTokens,
+          usageSource,
+          model: targetModel,
+          provider
+        }
+      })}
+
+`
+    );
+  };
+  if (provider === "google") {
+    try {
+      const ai = getGoogleAIClient(activeKey);
+      const formattedContents = messages.map((msg) => {
+        const isModel = msg.role === "model" || msg.role === "assistant" || msg.sender === "ai";
+        return {
+          role: isModel ? "model" : "user",
+          parts: [{ text: msg.content || " " }]
+        };
+      });
+      const config = {
+        temperature: Number(temperature) || 0.7
+      };
+      if (systemInstruction && systemInstruction.trim().length > 0) {
+        config.systemInstruction = systemInstruction.trim();
+      }
+      const responseStream = await ai.models.generateContentStream({
+        model: targetModel,
+        contents: formattedContents,
+        config
+      });
+      for await (const chunk of responseStream) {
+        const chunkText = chunk.text;
+        if (chunkText) {
+          fullAiText += chunkText;
+          res.write(`data: ${JSON.stringify({ text: chunkText })}
+
+`);
+        }
+        if (chunk.usageMetadata) {
+          inputTokens = chunk.usageMetadata.promptTokenCount || inputTokens;
+          outputTokens = chunk.usageMetadata.candidatesTokenCount || outputTokens;
+          totalTokens = chunk.usageMetadata.totalTokenCount || inputTokens + outputTokens;
+          cachedTokens = chunk.usageMetadata.cachedContentTokenCount || cachedTokens;
+          usageSource = "provider";
+        }
+      }
+      console.log(`[Stream] Google stream completed successfully for model: "${targetModel}"`);
+      finalizeAndSave("success");
+      res.write("data: [DONE]\n\n");
+      return res.end();
+    } catch (error) {
+      finalizeAndSave("error");
+      const { isApiKeyError, friendlyMessage } = classifyError(error);
+      console.error(`[Stream] Google stream error:`, error?.message);
+      res.write(
+        `data: ${JSON.stringify({
+          error: friendlyMessage,
+          errorType: isApiKeyError ? "INVALID_OR_EXPIRED_KEY" : "GENERAL_ERROR"
+        })}
+
+`
+      );
+      res.write("data: [DONE]\n\n");
+      return res.end();
+    }
+  }
+  if (provider === "claude") {
+    try {
+      const cleanBase = getTargetBaseUrl("claude", baseUrl);
+      const formattedClaudeMessages = messages.map((msg) => {
+        const isAI = msg.role === "model" || msg.role === "assistant" || msg.sender === "ai";
+        return {
+          role: isAI ? "assistant" : "user",
+          content: msg.content || " "
+        };
+      });
+      const response = await fetch(`${cleanBase}/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": activeKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: targetModel,
+          max_tokens: 4096,
+          system: systemInstruction && systemInstruction.trim().length > 0 ? systemInstruction.trim() : void 0,
+          messages: formattedClaudeMessages,
+          temperature: Number(temperature) || 0.7,
+          stream: true
+        })
+      });
+      if (!response.ok) {
+        finalizeAndSave("error");
+        const errorText = await response.text();
+        console.warn(`[Stream] Claude stream HTTP ${response.status}: ${errorText.slice(0, 100)}`);
+        let parsedError = errorText;
+        try {
+          const parsed = JSON.parse(errorText);
+          parsedError = parsed.error?.message || parsed.message || errorText;
+        } catch (e) {
+        }
+        const { isApiKeyError, friendlyMessage } = classifyError({ message: parsedError, status: response.status });
+        res.write(
+          `data: ${JSON.stringify({
+            error: friendlyMessage || parsedError,
+            errorType: isApiKeyError ? "INVALID_OR_EXPIRED_KEY" : "GENERAL_ERROR"
+          })}
+
+`
+        );
+        res.write("data: [DONE]\n\n");
+        return res.end();
+      }
+      if (!response.body) {
+        throw new Error("Anthropic Claude server did not open response stream.");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder("utf-8");
+      let buffer = "";
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("data: ")) {
+            const dataStr = trimmed.slice(6);
+            if (dataStr === "[DONE]") {
+              break;
+            }
+            try {
+              const parsed = JSON.parse(dataStr);
+              if (parsed.type === "message_start" && parsed.message?.usage) {
+                inputTokens = parsed.message.usage.input_tokens || 0;
+              }
+              if (parsed.type === "content_block_delta" && parsed.delta?.text) {
+                fullAiText += parsed.delta.text;
+                res.write(`data: ${JSON.stringify({ text: parsed.delta.text })}
+
+`);
+              }
+              if (parsed.type === "message_delta" && parsed.usage) {
+                outputTokens = parsed.usage.output_tokens || 0;
+                totalTokens = inputTokens + outputTokens;
+                usageSource = "provider";
+              }
+            } catch (err) {
+            }
+          }
+        }
+      }
+      console.log(`[Stream] Claude stream completed successfully for model: "${targetModel}"`);
+      finalizeAndSave("success");
+      res.write("data: [DONE]\n\n");
+      return res.end();
+    } catch (error) {
+      finalizeAndSave("error");
+      const { isApiKeyError, friendlyMessage } = classifyError(error);
+      console.error(`[Stream] Claude stream error:`, error?.message);
+      res.write(
+        `data: ${JSON.stringify({
+          error: friendlyMessage,
+          errorType: isApiKeyError ? "INVALID_OR_EXPIRED_KEY" : "GENERAL_ERROR"
+        })}
+
+`
+      );
+      res.write("data: [DONE]\n\n");
+      return res.end();
+    }
+  }
+  try {
+    const formattedMessages = [];
+    if (systemInstruction && systemInstruction.trim().length > 0) {
+      formattedMessages.push({
+        role: "system",
+        content: systemInstruction.trim()
+      });
+    }
+    for (const msg of messages) {
+      const isAI = msg.role === "model" || msg.role === "assistant" || msg.sender === "ai";
+      formattedMessages.push({
+        role: isAI ? "assistant" : "user",
+        content: msg.content || " "
+      });
+    }
+    const cleanBase = getTargetBaseUrl(provider, baseUrl) || (provider === "9router" ? DEFAULT_9ROUTER_BASE_URL : DEFAULT_OPENAI_BASE_URL);
+    const response = await fetch(`${cleanBase}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${activeKey}`
+      },
+      body: JSON.stringify({
+        model: targetModel,
+        messages: formattedMessages,
+        temperature: Number(temperature) || 0.7,
+        stream: true,
+        stream_options: { include_usage: true }
+      })
+    });
+    if (!response.ok) {
+      finalizeAndSave("error");
+      const errorText = await response.text();
+      console.warn(`[Stream] "${provider}" stream HTTP ${response.status}: ${errorText.slice(0, 100)}`);
+      let parsedError = errorText;
+      try {
+        const parsed = JSON.parse(errorText);
+        parsedError = parsed.error?.message || parsed.message || errorText;
+      } catch (e) {
+      }
+      const { isApiKeyError, friendlyMessage } = classifyError({ message: parsedError, status: response.status });
+      res.write(
+        `data: ${JSON.stringify({
+          error: friendlyMessage || parsedError,
+          errorType: isApiKeyError ? "INVALID_OR_EXPIRED_KEY" : "GENERAL_ERROR"
+        })}
+
+`
+      );
+      res.write("data: [DONE]\n\n");
+      return res.end();
+    }
+    if (!response.body) {
+      throw new Error("AI server did not open response stream.");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("data: ")) {
+          const dataStr = trimmed.slice(6);
+          if (dataStr === "[DONE]") {
+            break;
+          }
+          try {
+            const parsed = JSON.parse(dataStr);
+            if (parsed.usage) {
+              inputTokens = parsed.usage.prompt_tokens || 0;
+              outputTokens = parsed.usage.completion_tokens || 0;
+              totalTokens = parsed.usage.total_tokens || inputTokens + outputTokens;
+              cachedTokens = parsed.usage.prompt_tokens_details?.cached_tokens || 0;
+              reasoningTokens = parsed.usage.completion_tokens_details?.reasoning_tokens || 0;
+              usageSource = "provider";
+            }
+            const textChunk = parsed.choices?.[0]?.delta?.content || "";
+            if (textChunk) {
+              fullAiText += textChunk;
+              res.write(`data: ${JSON.stringify({ text: textChunk })}
+
+`);
+            }
+          } catch (err) {
+          }
+        }
+      }
+    }
+    console.log(`[Stream] "${provider}" stream completed successfully for model: "${targetModel}"`);
+    finalizeAndSave("success");
+    res.write("data: [DONE]\n\n");
+    return res.end();
+  } catch (error) {
+    finalizeAndSave("error");
+    const { isApiKeyError, friendlyMessage } = classifyError(error);
+    console.error(`[Stream] "${provider}" stream error:`, error?.message);
+    res.write(
+      `data: ${JSON.stringify({
+        error: friendlyMessage,
+        errorType: isApiKeyError ? "INVALID_OR_EXPIRED_KEY" : "GENERAL_ERROR"
+      })}
+
+`
+    );
+    res.write("data: [DONE]\n\n");
+    return res.end();
+  }
+});
+if (process.env.NODE_ENV === "production") {
+  app.use(express.static(path.resolve(__dirname, "dist")));
+  app.get("*", (_req, res) => {
+    res.sendFile(path.resolve(__dirname, "dist", "index.html"));
+  });
+} else {
+  const { createServer: createViteServer } = await import("vite");
+  const vite = await createViteServer({
+    server: { middlewareMode: true },
+    appType: "spa"
+  });
+  app.use(vite.middlewares);
+}
+const primaryServer = app.listen(PRIMARY_PORT, "0.0.0.0", () => {
+  console.log(`[Server] ChatAI server started and listening on http://0.0.0.0:${PRIMARY_PORT}`);
+});
+if (PRIMARY_PORT !== 8088) {
+  try {
+    const secondaryServer = app.listen(8088, "0.0.0.0", () => {
+      console.log(`[Server] ChatAI npm default listener active on http://0.0.0.0:8088`);
+    });
+    secondaryServer.on("error", (err) => {
+      console.log(`[Server] Secondary listener on port 8088 note: ${err.message}`);
+    });
+  } catch (err) {
+  }
+}