levix-bot 4.0.4 → 4.1.0

package/src/config/settings.cjs

@@ -42,6 +42,14 @@ const SETTINGS = [
     label: "Bot response language",
     hint: "Preferred language for AI replies and status updates. Can also be switched with !lang.",
   },
+  {
+    key: "link_previews_enabled",
+    type: "bool",
+    default: false,
+    group: "general",
+    label: "Link previews in messages",
+    hint: "Off (default) means the bot never fetches pages or images to preview a URL it sends — a real saving on mobile data, since AI answers with sources, short links and scheduled messages all contain URLs. On lets WhatsApp-style previews generate (one page fetch per URL sent).",
+  },
   {
     key: "bot_min_delay_ms",
     type: "int",
@@ -306,10 +314,10 @@ const SETTINGS = [
   {
     key: "thumbnail_remote",
     type: "bool",
-    default: true,
+    default: false,
     group: "media",
     label: "Previews for remote media",
-    hint: "Download media sent by URL to build a thumbnail before forwarding it.",
+    hint: "Off (default) keeps the bot from downloading media over the network just to build a thumbnail — send paths pass local files or buffers, so this rarely matters. On allows fetching a remote URL (up to the size limit below) when a send is given media by URL.",
   },
   {
     key: "thumbnail_remote_max_mb",

package/src/core/connection.js

@@ -182,8 +182,24 @@ async function saveBotOwnerMetadata(sock) {
   }
 }
 
-// Cache all group metadata
-async function cacheAllGroups(sock) {
+// Cache all group metadata — but not on every reconnect.
+//
+// Low-data design: `groupFetchAllParticipating()` pulls every group WITH its
+// participants and description, and it used to run on every connection open —
+// up to six times during one retry ladder. The full roster is only fetched
+// when the last one is older than the TTL below (or on the first open after a
+// process start, or explicitly forced); in between, pushed `groups.upsert` /
+// `groups.update` events keep the cache current, and per-message reads fall
+// back to single-group queries through resolveGroupMetadata() on a miss.
+export const GROUP_SYNC_TTL_MS = 6 * 60 * 60 * 1000; // 6 hours
+let lastFullGroupSyncAt = 0;
+
+export async function cacheAllGroups(sock, { force = false, now = Date.now() } = {}) {
+  if (!force && lastFullGroupSyncAt && now - lastFullGroupSyncAt < GROUP_SYNC_TTL_MS) {
+    logger.info("[Cache] Recent full group sync is still fresh — skipping groupFetchAllParticipating");
+    return;
+  }
+
   logger.info("[Cache] Fetching and caching metadata for all groups...");
 
   try {
@@ -199,6 +215,9 @@ async function cacheAllGroups(sock) {
       cachedCount++;
     }
 
+    // Only a successful fetch counts as fresh — a failed one retries on the
+    // next connection open.
+    lastFullGroupSyncAt = now;
     logger.info(`[Cache] Successfully cached ${cachedCount} groups.`);
   } catch (err) {
     logger.error("[Error] Failed to fetch and cache groups:", err);

package/src/core/socket.js

@@ -1,22 +1,45 @@
 import { makeWASocket } from "@whiskeysockets/baileys";
 import { createRequire } from "module";
-import NodeCache from "node-cache";
 import { useDatabaseAuthState } from "../auth/use-database-auth-state.js";
 import { getBaileysConfig, setRecentMessageGetter } from "../config/baileys.config.js";
-import { CACHE_CONFIG } from "../config/constants.js";
 import { getMessageFromRecent } from "../utils/recentMessageCache.esm.js";
 
 const require = createRequire(import.meta.url);
 const logger = require("../utils/logger.cjs");
 const { withMediaThumbnail } = require("../utils/thumbnail.cjs");
+const settings = require("../config/settings.cjs");
 
-// Group metadata cache
-export const groupMetadataCache = new NodeCache(CACHE_CONFIG);
+// The group-metadata cache lives in one shared CJS module so the CJS command
+// files and these ESM core files see the SAME instance (see
+// src/utils/groupMetadataCache.cjs). Re-exported under the historical name,
+// so every existing import site keeps working.
+const groupMetadataCacheModule = require("../utils/groupMetadataCache.cjs");
+export const groupMetadataCache = groupMetadataCacheModule.cache;
 
 // Wire the recent-message cache into Baileys' getMessage hook so retries can
 // recover (rc10 enableAutoSessionRecreation needs this).
 setRecentMessageGetter(getMessageFromRecent);
 
+/**
+ * Link previews are opt-in. Baileys fetches the page behind any URL in an
+ * outgoing text whenever `linkPreview` is merely undefined — with high-quality
+ * previews on it even uploads the page image. That made every AI answer with a
+ * Sources block, every short link and every scheduled message with a URL cost
+ * a silent page fetch. `linkPreview: null` skips it entirely; the operator
+ * opts back in with the `link_previews_enabled` setting (default off).
+ *
+ * This is the ONE choke point every outbound message passes through
+ * (sendBotMessage, the scheduler, status edits, legacy sock.sendMessage), so
+ * the guard lives here next to the thumbnail patch it shares a wrapper with.
+ */
+function withoutUnwantedLinkPreview(content) {
+  if (!content || typeof content !== "object") return content;
+  if (typeof content.text !== "string") return content;
+  if ("linkPreview" in content) return content; // caller decided already
+  if (settings.get("link_previews_enabled")) return content; // operator opted in
+  return { ...content, linkPreview: null };
+}
+
 /**
  * Baileys can't generate media previews in this install (no sharp/jimp, and its
  * video path shells out to a bare `ffmpeg` that isn't on the PATH), so every
@@ -25,10 +48,10 @@ setRecentMessageGetter(getMessageFromRecent);
  * sendBotMessage and the handful of legacy commands still calling
  * sock.sendMessage directly.
  */
-function withThumbnailSupport(sock) {
+function withOutboundSavers(sock) {
   const original = sock.sendMessage.bind(sock);
 
-  sock.sendMessage = async function sendMessageWithThumbnail(jid, content, options) {
+  sock.sendMessage = async function sendMessageWithOutboundSavers(jid, content, options) {
     let payload = content;
     try {
       payload = await withMediaThumbnail(content);
@@ -36,6 +59,7 @@ function withThumbnailSupport(sock) {
       logger.debug({ err: err?.message }, "[Socket] thumbnail step skipped");
       payload = content;
     }
+    payload = withoutUnwantedLinkPreview(payload);
     return original(jid, payload, options);
   };
 
@@ -83,7 +107,7 @@ export async function createWhatsAppSocket({ proxy = null, pairingCode = false }
     config.options = { ...(config.options || {}), dispatcher: proxy.dispatcher };
   }
 
-  const sock = withThumbnailSupport(
+  const sock = withOutboundSavers(
     makeWASocket({
       auth: state,
       ...config,

package/src/db/store.cjs

@@ -792,6 +792,28 @@ function deleteAllChatHistories() {
   q("DELETE FROM ai_history").run();
 }
 
+// Read-only views for the dashboard's conversation inspector: which chats
+// have stored history (no message content), and one chat's history with its
+// last-updated stamp. `json_array_length` counts the stored turns without
+// parsing the blob in JavaScript.
+function listChatHistories() {
+  return q(
+    `SELECT chat_id AS chatId,
+            updated_at AS updatedAt,
+            json_array_length(history) AS turns
+     FROM ai_history
+     ORDER BY updated_at DESC`,
+  ).all();
+}
+
+function getChatHistoryWithMeta(chatId) {
+  const row = q("SELECT history, updated_at AS updatedAt FROM ai_history WHERE chat_id = ?").get(
+    chatId,
+  );
+  if (!row) return null;
+  return { history: parseJson(row.history, []), updatedAt: row.updatedAt };
+}
+
 // ===================================================================
 // --- Baileys auth ---
 // ===================================================================
@@ -975,6 +997,8 @@ module.exports = {
   countSchedules,
   // AI history
   getChatHistory,
+  getChatHistoryWithMeta,
+  listChatHistories,
   saveChatHistory,
   deleteChatHistory,
   deleteAllChatHistories,

package/src/handlers/command.handler.js

@@ -4,6 +4,7 @@ import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { checkBotAdmin, checkCommandPermission } from "../middleware/permissions.middleware.js";
 import { sendBotMessage } from "../utils/sendBotMessage.esm.js";
+import { resolveGroupMetadata } from "../utils/groupMetadataCache.cjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -289,9 +290,10 @@ export async function handleCommand(sock, msg, body) {
   }
 
   try {
-    const groupMetadata = isGroup
-      ? await sock.groupMetadata(msg.key.remoteJid).catch(() => null)
-      : null;
+    // Cache-first: a live query only when no cached metadata exists yet (see
+    // utils/groupMetadataCache.cjs — this used to be one network round-trip
+    // per command attempt in every group).
+    const groupMetadata = isGroup ? await resolveGroupMetadata(sock, msg.key.remoteJid) : null;
 
     if (command.name !== "group") {
       // Enforce the `chat` constraint declared by the command. Until now this

package/src/middleware/antispam.middleware.js

@@ -7,6 +7,7 @@ import {
   sameUser,
 } from "../utils/permissions.esm.js";
 import { getGroupSettings, getPnForLid } from "../utils/storage.esm.js";
+import { resolveGroupMetadata } from "../utils/groupMetadataCache.cjs";
 
 const require = createRequire(import.meta.url);
 const logger = require("../utils/logger.cjs");
@@ -41,7 +42,9 @@ export async function handleAntiSpam(sock, msg) {
   // Owners and admins are immune. The legacy owner mirror it used to import was
   // only ever populated with the bot's own JID, so real operators were
   // counted as spammers — the centralized check fixes that.
-  const groupMetadata = await sock.groupMetadata(groupId);
+  // Cache-first: antispam runs on EVERY group message, so this read must not
+  // be a live query (see utils/groupMetadataCache.cjs).
+  const groupMetadata = await resolveGroupMetadata(sock, groupId);
   const protectedSender = senderCandidates.some(
     (candidate) =>
       isOwnerJid(candidate) ||

package/src/middleware/blacklist.middleware.js

@@ -1,6 +1,7 @@
 import { createRequire } from "module";
 import { getSenderCandidates, isAdminInGroup, sameUser } from "../utils/permissions.esm.js";
 import { getGroupSettings } from "../utils/storage.esm.js";
+import { resolveGroupMetadata } from "../utils/groupMetadataCache.cjs";
 
 const require = createRequire(import.meta.url);
 const logger = require("../utils/logger.cjs");
@@ -19,7 +20,9 @@ export async function checkBlacklist(sock, msg) {
   );
 
   if (listed) {
-    const groupMetadata = await sock.groupMetadata(groupId);
+    // Cache-first: admin detection for a blacklisted sender, only when the
+    // blacklist actually matched (see utils/groupMetadataCache.cjs).
+    const groupMetadata = await resolveGroupMetadata(sock, groupId);
     const isSenderAdmin = senderCandidates.some((candidate) =>
       isAdminInGroup(groupMetadata, candidate),
     );

package/src/middleware/permissions.middleware.js

@@ -11,6 +11,7 @@ import {
 
 const require = createRequire(import.meta.url);
 const runtimeConfig = require("../config/runtime-config.cjs");
+const { evaluatePermissionLevel } = require("../utils/permissionLevel.cjs");
 const logger = require("../utils/logger.cjs");
 
 /**
@@ -28,79 +29,65 @@ function resolvePermissionLevel(commandName) {
 }
 
 /**
- * Check if user has permission to execute a command.
+ * Who sent `msg`, as far as permissions are concerned. The same answer backs
+ * the command dispatcher and the AI agent's tools (services/aiToolAuth.cjs),
+ * so a person is never an admin for one door and a member for the other.
  *
- * @param {string} commandName - Canonical command name
- * @param {object} msg          - Baileys message
+ * @param {object} msg           - Baileys message
  * @param {object} groupMetadata - Group metadata (null for private chats)
  * @param {object} sock          - Baileys socket
- * @returns {{hasPermission: boolean, reason: string, isOwner: boolean, isSenderAdmin: boolean}}
+ * @returns {{isGroup: boolean, senderId: string|null, candidates: string[],
+ *            isOwner: boolean, isBotAdmin: boolean, isGroupAdmin: boolean,
+ *            isSenderAdmin: boolean}}
  */
-export function checkCommandPermission(commandName, msg, groupMetadata, sock) {
-  const isGroup = msg.key.remoteJid?.endsWith("@g.us");
+export function resolveSender(msg, groupMetadata, sock) {
+  const isGroup = Boolean(msg?.key?.remoteJid?.endsWith("@g.us"));
   const senderId = getSenderId(msg, sock);
 
   // v7/LID: check every identifier the sender could appear under (LID + PN
   // alternates), so owner/admin detection isn't defeated by a LID<->PN mismatch.
   const senderCandidates = getSenderCandidates(msg, sock);
-  const candidates = senderCandidates.length ? senderCandidates : [senderId];
+  const candidates = senderCandidates.length ? senderCandidates : [senderId].filter(Boolean);
 
   // fromMe is an immediate owner indicator (the bot is always its own owner).
-  const isOwner = msg.key.fromMe || candidates.some((c) => isOwnerJid(c));
+  const isOwner = Boolean(msg?.key?.fromMe) || candidates.some((c) => isOwnerJid(c));
 
   // Bot-level admins (granted with `!perm add admin`, from the dashboard, or by
   // asking the AI) count as admins everywhere — including DMs, where there is
   // no group roster to consult.
   const isBotAdmin = !isOwner && candidates.some((c) => isBotAdminUser(c));
 
-  const isSenderAdmin =
-    isBotAdmin || (isGroup ? candidates.some((c) => isAdminInGroup(groupMetadata, c)) : false);
+  const isGroupAdmin = isGroup && candidates.some((c) => isAdminInGroup(groupMetadata, c));
+  const isSenderAdmin = isBotAdmin || isGroupAdmin;
 
-  const permissionLevel = resolvePermissionLevel(commandName);
-
-  let hasPermission = false;
-  let reason = "";
-
-  switch (permissionLevel) {
-    case "MEMBERS":
-    case "ALL":
-      hasPermission = true;
-      break;
-
-    case "OWNER_ONLY":
-      hasPermission = isOwner;
-      reason = "🚫 هذا الأمر متاح للمالك فقط.";
-      break;
-
-    case "ADMINS_ONLY":
-      if (!isGroup) {
-        // Owners and bot-admins can run admin-only commands from anywhere —
-        // useful for the operator pinging the bot privately to manage a group.
-        hasPermission = isOwner || isBotAdmin;
-        reason = "⚠️ هذا الأمر يعمل في المجموعات فقط (أو للمالك في الخاص).";
-      } else {
-        hasPermission = isSenderAdmin || isOwner;
-        reason = "🚫 هذا الأمر متاح للمشرفين فقط.";
-      }
-      break;
+  return { isGroup, senderId, candidates, isOwner, isBotAdmin, isGroupAdmin, isSenderAdmin };
+}
 
-    case "ADMINS_OWNER":
-      if (!isGroup) {
-        hasPermission = isOwner || isBotAdmin;
-        reason = "⚠️ هذا الأمر يعمل في المجموعات أو للمالك فقط.";
-      } else {
-        hasPermission = isOwner || isSenderAdmin;
-        reason = "🚫 هذا الأمر متاح للمشرفين والمالك فقط.";
-      }
-      break;
+/**
+ * Check if user has permission to execute a command.
+ *
+ * @param {string} commandName - Canonical command name
+ * @param {object} msg          - Baileys message
+ * @param {object} groupMetadata - Group metadata (null for private chats)
+ * @param {object} sock          - Baileys socket
+ * @returns {{hasPermission: boolean, reason: string, isOwner: boolean, isSenderAdmin: boolean}}
+ */
+export function checkCommandPermission(commandName, msg, groupMetadata, sock) {
+  const sender = resolveSender(msg, groupMetadata, sock);
+  const permissionLevel = resolvePermissionLevel(commandName);
+  const { hasPermission, reason, unknownLevel } = evaluatePermissionLevel(permissionLevel, sender);
 
-    default:
-      logger.warn(`Unknown permission level: ${permissionLevel} for command: ${commandName}`);
-      hasPermission = false;
-      reason = "🚫 مستوى الصلاحية غير معروف.";
+  if (unknownLevel) {
+    logger.warn(`Unknown permission level: ${permissionLevel} for command: ${commandName}`);
   }
 
-  return { hasPermission, reason, isOwner, isSenderAdmin, isBotAdmin };
+  return {
+    hasPermission,
+    reason,
+    isOwner: sender.isOwner,
+    isSenderAdmin: sender.isSenderAdmin,
+    isBotAdmin: sender.isBotAdmin,
+  };
 }
 
 /**

package/src/routes/dashboard.api.esm.js

@@ -323,6 +323,8 @@ router.patch("/settings", (req, res) => {
         visionEnabled: key === "ai_vision_enabled" ? value : settings.get("ai_vision_enabled"),
         sttEnabled: key === "ai_stt_enabled" ? value : settings.get("ai_stt_enabled"),
         capabilities: resolved.capabilities,
+        capabilitySource: resolved.capabilitySource,
+        autoDetect: settings.get("ai_auto_detect_capabilities"),
       });
       if (key === "ai_vision_enabled") value = next.visionEnabled;
       if (key === "ai_stt_enabled") value = next.sttEnabled;
@@ -359,6 +361,8 @@ router.patch("/settings", (req, res) => {
         visionEnabled: settings.get("ai_vision_enabled"),
         sttEnabled: settings.get("ai_stt_enabled"),
         capabilities: resolved.capabilities,
+        capabilitySource: resolved.capabilitySource,
+        autoDetect: settings.get("ai_auto_detect_capabilities"),
       });
       if (Boolean(settings.get("ai_vision_enabled")) !== next.visionEnabled) {
         settings.set("ai_vision_enabled", next.visionEnabled);
@@ -512,16 +516,16 @@ router.get("/ai/memory", (req, res) => {
   try {
     const scopes = [];
 
-    if (fs.existsSync(memory.GLOBAL_FILE)) {
-      const stat = fs.statSync(memory.GLOBAL_FILE);
-      scopes.push({
-        scope: "global",
-        label: "Global memory",
-        entries: memory.listMemory({ scope: "global" }).length,
-        bytes: stat.size,
-        updatedAt: stat.mtimeMs,
-      });
-    }
+    // Global is always offered — even before the file exists — so the editor
+    // can create it with the first save.
+    const stat = fs.existsSync(memory.GLOBAL_FILE) ? fs.statSync(memory.GLOBAL_FILE) : null;
+    scopes.push({
+      scope: "global",
+      label: "Global memory",
+      entries: memory.listMemory({ scope: "global" }).length,
+      bytes: stat?.size ?? 0,
+      updatedAt: stat?.mtimeMs ?? null,
+    });
 
     if (fs.existsSync(memory.CHATS_DIR)) {
       for (const file of fs.readdirSync(memory.CHATS_DIR)) {
@@ -581,6 +585,83 @@ router.delete("/ai/memory/:scope", (req, res) => {
   }
 });
 
+// ===========================================================================
+// AI conversation inspector — read-only views of the stored `ai_history`
+//
+// The bot deliberately keeps only its own conversation windows, and the panel
+// may look at them but never change them: deletes stay with `!del` / `!delall`
+// in WhatsApp, so this endpoint is GET-only on purpose.
+// ===========================================================================
+
+const MAX_INSPECTOR_MESSAGES = 200;
+const MAX_INSPECTOR_TEXT_CHARS = 2000;
+
+router.get("/ai/conversations", (req, res) => {
+  getChatHistoryListAsync()
+    .then((conversations) => res.json({ success: true, conversations }))
+    .catch((error) => fail(res, error, "Error listing conversations"));
+});
+
+router.get("/ai/conversations/:chatId", (req, res) => {
+  getChatConversationAsync(req.params.chatId)
+    .then((conversation) => {
+      if (!conversation) return badRequest(res, "No stored conversation for that chat");
+      res.json({ success: true, ...conversation });
+    })
+    .catch((error) => fail(res, error, "Error reading conversation"));
+});
+
+async function getChatHistoryListAsync() {
+  const { listChatHistoriesAsync } = require("../utils/storage-hub.cjs");
+  const rows = await listChatHistoriesAsync();
+  return (rows || []).map((row) => ({
+    chatId: row.chatId,
+    turns: row.turns ?? 0,
+    updatedAt: row.updatedAt ?? null,
+  }));
+}
+
+// Flatten the canonical Gemini-parts history into display rows: text, media
+// references (mime only — the bytes were never stored) and tool activity.
+// Oldest first, capped to the most recent MAX_INSPECTOR_MESSAGES rows.
+async function getChatConversationAsync(chatId) {
+  const { getChatHistoryWithMetaAsync } = require("../utils/storage-hub.cjs");
+  const meta = await getChatHistoryWithMetaAsync(chatId);
+  if (!meta) return null;
+
+  const messages = [];
+  for (const entry of Array.isArray(meta.history) ? meta.history : []) {
+    const role = entry?.role === "model" ? "model" : "user";
+    for (const part of Array.isArray(entry?.parts) ? entry.parts : []) {
+      if (messages.length >= MAX_INSPECTOR_MESSAGES) break;
+      if (typeof part?.text === "string" && part.text.trim()) {
+        messages.push({ role, kind: "text", text: part.text.slice(0, MAX_INSPECTOR_TEXT_CHARS) });
+      } else if (part?.fileData || part?.inlineData) {
+        messages.push({
+          role,
+          kind: "media",
+          mimeType: part?.fileData?.mimeType || part?.inlineData?.mimeType || null,
+        });
+      } else if (part?.functionCall) {
+        messages.push({
+          role: "model",
+          kind: "tool",
+          name: part.functionCall.name || "unknown",
+        });
+      } else if (part?.functionResponse) {
+        messages.push({
+          role: "user",
+          kind: "toolResult",
+          name: part.functionResponse.name || "unknown",
+        });
+      }
+    }
+    if (messages.length >= MAX_INSPECTOR_MESSAGES) break;
+  }
+
+  return { chatId, updatedAt: meta.updatedAt ?? null, truncated: messages.length >= MAX_INSPECTOR_MESSAGES, messages };
+}
+
 // ===========================================================================
 // Groups
 // ===========================================================================

package/src/services/aiAgent.cjs

@@ -399,7 +399,9 @@ function formatSources(sources) {
  * @param {Array}    options.parts    - the Gemini parts for this message
  * @param {Array}    [options.history]- prior conversation
  * @param {object}   [options.status] - live status message (see utils/statusMessage.cjs)
- * @param {object}   [options.context]- { chatId, senderId, senderName, isOwner, isAdmin, isGroup, chatName }
+ * @param {object}   [options.context]- { caller, chatId, senderId, senderName, isOwner, isAdmin, isGroup, chatName }
+ *                                      `caller` (aiToolAuth.resolveCaller) is the only thing the
+ *                                      tools authorize against; the rest feeds the system prompt.
  * @param {boolean}  [options.useTools=true]
  * @returns {Promise<{text: string, history: Array, toolCalls: Array, steps: number}>}
  */
@@ -499,6 +501,7 @@ async function runGeminiTurn({
   useTools = true,
   maxSteps = null,
   systemInstruction = null,
+  search = null,
 } = {}) {
   const genAI = geminiClient();
   if (!genAI) throw new Error("GEMINI_API_KEY غير معرف");
@@ -530,7 +533,9 @@ async function runGeminiTurn({
     });
   };
 
-  let searchOffered = googleSearchEnabled();
+  // One-shot callers (the summarize tool) pass search:false explicitly; the
+  // chat agent follows the setting.
+  let searchOffered = search === null ? googleSearchEnabled() : Boolean(search);
   let chat = openChat(searchOffered);
   const toolCalls = [];
   // Only ever filled from real grounding metadata; see extractSources().

package/src/services/aiRouter.cjs

@@ -115,13 +115,20 @@ function detectModelCapabilities(provider = settings.get("ai_provider"), model =
   const resolved = resolveCapabilities(p, m);
   const caps = resolved.capabilities;
 
+  // "Unknown" is not "unsupported": for a model the registry has never seen
+  // (a gateway's own ids, a model newer than the catalog) the operator's
+  // toggles are the only gate, so report the capability as available and let
+  // ai_vision_enabled / ai_stt_enabled decide. Forcing it false here would
+  // silently drop every image/audio part on custom endpoints.
+  const known = resolved.capabilitySource === "seed" || resolved.capabilitySource === "provider";
+
   return {
     provider: p,
     model: m,
     capabilities: caps,
     capabilitySource: resolved.capabilitySource,
-    supportsVision: Boolean(caps.vision),
-    supportsAudioStt: Boolean(caps.stt),
+    supportsVision: known ? Boolean(caps.vision) : true,
+    supportsAudioStt: known ? Boolean(caps.stt) : true,
     visionRecommended: Boolean(caps.vision) && !settings.get("ai_vision_enabled"),
   };
 }