levix-bot 3.3.0-rc.2 → 4.0.0-beta

package/src/services/aiTools.cjs

@@ -13,6 +13,8 @@
 // isn't allowed to do it.
 
 const dns = require("node:dns").promises;
+const http = require("node:http");
+const https = require("node:https");
 const net = require("node:net");
 
 const axios = require("axios");
@@ -20,11 +22,8 @@ const axios = require("axios");
 const logger = require("../utils/logger.cjs");
 const memory = require("../utils/memory.cjs");
 const { decodeBuffer, stripHtml, decodeText } = require("../utils/textDecode.cjs");
-const {
-  grantRole,
-  revokeRole,
-  listRoles,
-} = require("../utils/permissions.cjs");
+const { grantRole, revokeRole, listRoles } = require("../utils/permissions.cjs");
+const { isForbiddenIp } = require("../utils/providerUrl.cjs");
 
 // @google/genai exports a `Type` enum (the old SDK called it `SchemaType`).
 // Its members are the uppercase wire values — Type.STRING === "STRING" — so the
@@ -83,16 +82,11 @@ async function searchDuckDuckGo(query, limit) {
     validateStatus: (status) => status >= 200 && status < 500,
   });
 
-  const html = decodeBuffer(
-    Buffer.from(response.data),
-    response.headers["content-type"]
-  );
+  const html = decodeBuffer(Buffer.from(response.data), response.headers["content-type"]);
 
   const results = [];
-  const linkRe =
-    /<a[^>]+class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
-  const snippetRe =
-    /<a[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
+  const linkRe = /<a[^>]+class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+  const snippetRe = /<a[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
 
   const snippets = [];
   let snippetMatch;
@@ -114,18 +108,15 @@ async function searchDuckDuckGo(query, limit) {
 }
 
 async function searchGoogleCse(query, limit) {
-  const response = await axios.get(
-    "https://www.googleapis.com/customsearch/v1",
-    {
-      params: {
-        key: settings.get("google_search_api_key"),
-        cx: settings.get("google_search_cx"),
-        q: query,
-        num: Math.min(10, limit),
-      },
-      timeout: 20000,
-    }
-  );
+  const response = await axios.get("https://www.googleapis.com/customsearch/v1", {
+    params: {
+      key: settings.get("google_search_api_key"),
+      cx: settings.get("google_search_cx"),
+      q: query,
+      num: Math.min(10, limit),
+    },
+    timeout: 20000,
+  });
   return (response.data?.items || []).slice(0, limit).map((item) => ({
     title: item.title,
     url: item.link,
@@ -147,6 +138,85 @@ async function webSearch(query, limit = 5) {
   return searchDuckDuckGo(query, limit);
 }
 
+async function searchNews(query, limit = 5) {
+  const newsQuery = `${query} news أخبار`;
+  return webSearch(newsQuery, limit);
+}
+
+async function enrichWikiResults(lang, titles, urls, limit) {
+  const count = Math.min(titles?.length || 0, limit);
+  const items = [];
+  for (let i = 0; i < count; i++) {
+    items.push({ title: titles[i], url: urls[i] });
+  }
+
+  const results = await Promise.all(
+    items.map(async ({ title, url }) => {
+      let extract = "";
+      try {
+        const summaryRes = await axios.get(
+          `https://${lang}.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(title)}`,
+          {
+            timeout: 8000,
+            headers: { "User-Agent": "LevixBot/3.4 (https://github.com/Abdodiab2005/levix)" },
+          },
+        );
+        extract = summaryRes.data?.extract || summaryRes.data?.description || "";
+      } catch {
+        // Non-fatal: summary lookup failure retains title and URL.
+      }
+      return { title, url, extract: extract.slice(0, 1000) };
+    }),
+  );
+
+  return { language: lang, count: results.length, results };
+}
+
+async function searchWikipedia(query, language = "auto", limit = 3) {
+  let lang = language;
+  if (!lang || lang === "auto") {
+    lang = /[\u0600-\u06FF]/.test(query) ? "ar" : "en";
+  }
+  const cleanLang = lang.toLowerCase() === "ar" ? "ar" : "en";
+  try {
+    const searchRes = await axios.get(`https://${cleanLang}.wikipedia.org/w/api.php`, {
+      params: {
+        action: "opensearch",
+        search: query,
+        limit: Math.min(5, Math.max(1, limit)),
+        namespace: 0,
+        format: "json",
+      },
+      timeout: 10000,
+      headers: { "User-Agent": "LevixBot/3.4 (https://github.com/Abdodiab2005/levix)" },
+    });
+    const [, titles, , urls] = searchRes.data || [];
+    if (!titles || !titles.length) {
+      const altLang = cleanLang === "ar" ? "en" : "ar";
+      const altRes = await axios.get(`https://${altLang}.wikipedia.org/w/api.php`, {
+        params: {
+          action: "opensearch",
+          search: query,
+          limit: Math.min(5, Math.max(1, limit)),
+          namespace: 0,
+          format: "json",
+        },
+        timeout: 10000,
+        headers: { "User-Agent": "LevixBot/3.4 (https://github.com/Abdodiab2005/levix)" },
+      });
+      const [, altTitles, , altUrls] = altRes.data || [];
+      if (!altTitles || !altTitles.length) {
+        return { query, count: 0, results: [], note: "no Wikipedia articles found" };
+      }
+      return await enrichWikiResults(altLang, altTitles, altUrls, limit);
+    }
+    return await enrichWikiResults(cleanLang, titles, urls, limit);
+  } catch (err) {
+    logger.warn({ err: err.message }, "[aiTools] Wikipedia search failed");
+    return { error: `Wikipedia search failed: ${err.message}` };
+  }
+}
+
 // ---------------------------------------------------------------------------
 // url fetching
 // ---------------------------------------------------------------------------
@@ -157,49 +227,9 @@ async function webSearch(query, limit = 5) {
 // و 2130706433 و [::ffff:127.0.0.1] نفس العنوان بصيغة تانية، والأهم إن رابط
 // عام ممكن يعمل redirect على 169.254.169.254 (مفاتيح السيرفر عند أغلب
 // مزودي الاستضافة). فبنـ resolve العنوان ونفحص كل خطوة تحويل لوحدها.
-// ::ffff:127.0.0.1 بيتكتب برضه ::ffff:7f00:1 — والـ URL parser بيطبّع الشكل
-// التاني، فلازم نفك الصيغة السداسية كمان مش الشكل بالنقط بس.
-function mappedIpv4(v6) {
-  const dotted = /^::(?:ffff:)?(\d+\.\d+\.\d+\.\d+)$/.exec(v6);
-  if (dotted) return dotted[1];
-
-  const hex = /^::(?:ffff:)?([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(v6);
-  if (!hex) return null;
-  const high = parseInt(hex[1], 16);
-  const low = parseInt(hex[2], 16);
-  return `${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`;
-}
-
-function isPrivateIp(ip) {
-  const family = net.isIP(ip);
-
-  if (family === 4) {
-    const [a, b] = ip.split(".").map(Number);
-    if (a === 0 || a === 10 || a === 127) return true;
-    if (a === 169 && b === 254) return true; // link-local + metadata
-    if (a === 172 && b >= 16 && b <= 31) return true;
-    if (a === 192 && b === 168) return true;
-    if (a === 100 && b >= 64 && b <= 127) return true; // CGNAT
-    if (a >= 224) return true; // multicast + reserved
-    return false;
-  }
-
-  if (family === 6) {
-    const v6 = ip.toLowerCase();
-    if (v6 === "::" || v6 === "::1") return true;
-    if (/^f[cd]/.test(v6)) return true; // unique local
-    if (v6.startsWith("fe80")) return true; // link local
-    const mapped = mappedIpv4(v6);
-    if (mapped) return isPrivateIp(mapped);
-    return false;
-  }
-
-  return true; // مش عنوان صالح أصلاً
-}
-
-// ملاحظة: فيه فرصة نظرية إن الـ DNS يرد بعنوان تاني بين الفحص والاتصال
-// (DNS rebinding). قفلها بالكامل محتاج تثبيت الـ IP على مستوى الـ socket؛
-// اللي هنا بيقفل الحالات العملية: أسماء داخلية، صيغ IP بديلة، والتحويلات.
+// Resolve once, reject every local/reserved answer, then pin the HTTP socket to
+// one of those exact answers. That closes the gap where a rebinding hostname
+// could return a public address during validation and loopback during connect.
 async function assertPublicUrl(rawUrl) {
   let url;
   try {
@@ -212,61 +242,97 @@ async function assertPublicUrl(rawUrl) {
   const host = url.hostname.replace(/^\[|\]$/g, "");
 
   if (net.isIP(host)) {
-    if (isPrivateIp(host)) throw new Error("الرابط ده ممنوع");
-    return url;
+    if (isForbiddenIp(host)) throw new Error("الرابط ده ممنوع");
+    return { url, host, addresses: [{ address: host, family: net.isIP(host) }] };
   }
 
   let addresses;
   try {
-    addresses = await dns.lookup(host, { all: true });
+    addresses = await dns.lookup(host, { all: true, verbatim: true });
   } catch {
     throw new Error("مش قادر أوصل للدومين ده");
   }
-  if (!addresses.length || addresses.some((a) => isPrivateIp(a.address))) {
+  if (!addresses.length || addresses.some((a) => isForbiddenIp(a.address))) {
     throw new Error("الرابط ده ممنوع");
   }
 
-  return url;
+  return { url, host, addresses };
+}
+
+function pinnedAgent(protocol, expectedHost, addresses) {
+  const lookup = (hostname, options, callback) => {
+    if (String(hostname).toLowerCase() !== expectedHost.toLowerCase()) {
+      const error = new Error("اتصال بدومين غير متوقع");
+      error.code = "EAI_FAIL";
+      return callback(error);
+    }
+
+    const requestedFamily = typeof options === "number" ? options : options?.family;
+    const candidates = requestedFamily
+      ? addresses.filter(({ family }) => family === requestedFamily)
+      : addresses;
+    if (!candidates.length) {
+      const error = new Error("مفيش عنوان متوافق للدومين ده");
+      error.code = "EAI_ADDRFAMILY";
+      return callback(error);
+    }
+    if (typeof options === "object" && options?.all) {
+      return callback(null, candidates.map(({ address, family }) => ({ address, family })));
+    }
+    return callback(null, candidates[0].address, candidates[0].family);
+  };
+
+  const Agent = protocol === "https:" ? https.Agent : http.Agent;
+  return new Agent({ keepAlive: false, lookup });
 }
 
 const MAX_REDIRECTS = 4;
 
 async function fetchUrl(rawUrl) {
-  let url = await assertPublicUrl(rawUrl);
+  let target = await assertPublicUrl(rawUrl);
   let response;
 
   for (let hop = 0; ; hop++) {
-    response = await axios.get(url.toString(), {
-      responseType: "arraybuffer",
-      timeout: 20000,
-      // بنمشي ورا التحويلات بنفسنا عشان نفحص كل خطوة — axios بيفحص الأول بس.
-      maxRedirects: 0,
-      maxContentLength: MAX_FETCH_BYTES,
-      headers: {
-        "User-Agent": UA,
-        "Accept-Language": "ar,en;q=0.9",
-        Accept: "text/html,application/json,text/plain,*/*",
-      },
-      validateStatus: (status) => status >= 200 && status < 500,
-    });
+    const { url, host, addresses } = target;
+    const agent = pinnedAgent(url.protocol, host, addresses);
+    try {
+      response = await axios.get(url.toString(), {
+        responseType: "arraybuffer",
+        timeout: 20000,
+        // بنمشي ورا التحويلات بنفسنا عشان نفحص كل خطوة — axios بيفحص الأول بس.
+        maxRedirects: 0,
+        maxContentLength: MAX_FETCH_BYTES,
+        // Ignore process-wide proxy variables: they would perform their own
+        // hostname resolution and bypass the pinned lookup above.
+        proxy: false,
+        httpAgent: url.protocol === "http:" ? agent : undefined,
+        httpsAgent: url.protocol === "https:" ? agent : undefined,
+        headers: {
+          "User-Agent": UA,
+          "Accept-Language": "ar,en;q=0.9",
+          Accept: "text/html,application/json,text/plain,*/*",
+        },
+        validateStatus: (status) => status >= 200 && status < 500,
+      });
+    } finally {
+      agent.destroy();
+    }
 
     const location = response.headers?.location;
     const isRedirect = response.status >= 300 && response.status < 400 && location;
     if (!isRedirect) break;
     if (hop >= MAX_REDIRECTS) throw new Error("الرابط بيحوّل كتير أوي");
 
-    url = await assertPublicUrl(new URL(location, url).toString());
+    target = await assertPublicUrl(new URL(location, url).toString());
   }
 
   const contentType = String(response.headers["content-type"] || "");
   const body = decodeBuffer(Buffer.from(response.data), contentType);
 
-  const text = /json|text\/plain|xml/i.test(contentType)
-    ? body
-    : stripHtml(body);
+  const text = /json|text\/plain|xml/i.test(contentType) ? body : stripHtml(body);
 
   return {
-    url: url.toString(),
+    url: target.url.toString(),
     status: response.status,
     contentType,
     truncated: text.length > MAX_PAGE_CHARS,
@@ -285,16 +351,35 @@ function scopeOf(args) {
 // نفس قاعدة أمر !memory بالظبط: الكتابة في الذاكرة العامة والمسح محتاجين
 // أدمن/مالك. الفحص لازم يكون هنا مش في البرومبت — الموديل بيقرا صفحات ويب
 // ورسايل ناس، وأي واحدة فيهم ممكن تقوله "احفظ ده في الذاكرة العامة".
-function isPrivileged(ctx) {
+function isBotPrivileged(ctx) {
   return Boolean(ctx?.isOwner || ctx?.isAdmin);
 }
 
+function isChatMemoryAdmin(ctx) {
+  return isBotPrivileged(ctx) || Boolean(ctx?.isGroupAdmin);
+}
+
+function roleTargetBound(target, ctx) {
+  const raw = String(target || "").trim();
+  if (!raw) return false;
+  const ids = [...(ctx?.mentionedJids || []), ctx?.quotedParticipant].filter(Boolean);
+  const { sameUserSync } = require("../utils/permissions.cjs");
+  if (ids.some((id) => sameUserSync(id, raw))) return true;
+  const digits = raw.replace(/\D/g, "");
+  if (digits.length >= 8 && String(ctx?.userText || "").replace(/\D/g, "").includes(digits)) {
+    return true;
+  }
+  return false;
+}
+
 const NOT_PRIVILEGED = {
   error: "only the bot owner or an admin can do this",
 };
 
 function preview(value, length = 40) {
-  const text = String(value || "").replace(/\s+/g, " ").trim();
+  const text = String(value || "")
+    .replace(/\s+/g, " ")
+    .trim();
   return text.length > length ? `${text.slice(0, length)}...` : text;
 }
 
@@ -316,7 +401,8 @@ const TOOLS = {
         required: ["query"],
       },
     },
-    describe: (args) => `🔍 ببحث عن: ${preview(args?.query, 50)}`,
+    describe: (args) => `🔍 جاري البحث عن: ${preview(args?.query, 50)}`,
+    describeEn: (args) => `🔍 Searching for: ${preview(args?.query, 50)}`,
     async run(args) {
       const query = String(args?.query || "").trim();
       if (!query) return { error: "query is required" };
@@ -331,6 +417,77 @@ const TOOLS = {
     },
   },
 
+  search_wikipedia: {
+    declaration: {
+      name: "search_wikipedia",
+      description:
+        "Search Wikipedia for encyclopedic facts, history, science, biographies, definitions, and academic context in Arabic or English.",
+      parameters: {
+        type: T.OBJECT,
+        properties: {
+          query: {
+            type: T.STRING,
+            description: "The topic, entity, or term to look up.",
+          },
+          language: {
+            type: T.STRING,
+            description:
+              "'ar' for Arabic Wikipedia, 'en' for English Wikipedia, or 'auto' (detect from query).",
+          },
+          limit: {
+            type: T.INTEGER,
+            description: "How many articles to return (1-5, default 3).",
+          },
+        },
+        required: ["query"],
+      },
+    },
+    describe: (args) => `📚 جاري البحث في ويكيبيديا: ${preview(args?.query, 45)}`,
+    describeEn: (args) => `📚 Searching Wikipedia: ${preview(args?.query, 45)}`,
+    async run(args) {
+      const query = String(args?.query || "").trim();
+      if (!query) return { error: "query is required" };
+      const limit = Math.min(5, Math.max(1, Number(args?.limit) || 3));
+      return searchWikipedia(query, args?.language, limit);
+    },
+  },
+
+  search_news: {
+    declaration: {
+      name: "search_news",
+      description:
+        "Search recent news headlines, breaking events, press coverage, and current affairs.",
+      parameters: {
+        type: T.OBJECT,
+        properties: {
+          query: {
+            type: T.STRING,
+            description: "The news topic, person, or event to search for.",
+          },
+          limit: {
+            type: T.INTEGER,
+            description: "How many news results to return (1-8, default 5).",
+          },
+        },
+        required: ["query"],
+      },
+    },
+    describe: (args) => `📰 جاري البحث عن الأخبار: ${preview(args?.query, 45)}`,
+    describeEn: (args) => `📰 Searching news: ${preview(args?.query, 45)}`,
+    async run(args) {
+      const query = String(args?.query || "").trim();
+      if (!query) return { error: "query is required" };
+      const limit = Math.min(8, Math.max(1, Number(args?.limit) || 5));
+      const results = await searchNews(query, limit);
+      return {
+        query,
+        count: results.length,
+        results,
+        note: results.length ? undefined : "no recent news found",
+      };
+    },
+  },
+
   fetch_url: {
     declaration: {
       name: "fetch_url",
@@ -344,7 +501,8 @@ const TOOLS = {
         required: ["url"],
       },
     },
-    describe: (args) => `🌐 بفتح الرابط: ${preview(args?.url, 45)}`,
+    describe: (args) => `🌐 جاري فتح الرابط: ${preview(args?.url, 45)}`,
+    describeEn: (args) => `🌐 Opening link: ${preview(args?.url, 45)}`,
     async run(args) {
       const url = String(args?.url || "").trim();
       if (!url) return { error: "url is required" };
@@ -362,8 +520,7 @@ const TOOLS = {
         properties: {
           content: {
             type: T.STRING,
-            description:
-              "The fact to remember, written as a short standalone sentence.",
+            description: "The fact to remember, written as a short standalone sentence.",
           },
           scope: {
             type: T.STRING,
@@ -374,13 +531,17 @@ const TOOLS = {
       },
     },
     describe: (args) =>
-      `🧠 بحفظ في ${scopeOf(args) === "global" ? "الذاكرة العامة" : "ذاكرة الشات"}: ${preview(
-        args?.content
+      `🧠 جاري الحفظ في ${scopeOf(args) === "global" ? "الذاكرة العامة" : "ذاكرة المحادثة"}: ${preview(
+        args?.content,
+      )}`,
+    describeEn: (args) =>
+      `🧠 Saving to ${scopeOf(args) === "global" ? "global" : "chat"} memory: ${preview(
+        args?.content,
       )}`,
     async run(args, ctx) {
       const scope = scopeOf(args);
       // الذاكرة العامة بتتحقن في البرومبت بتاع كل الشاتات، فمش أي حد يكتب فيها.
-      if (scope === "global" && !isPrivileged(ctx)) {
+      if (scope === "global" && !isBotPrivileged(ctx)) {
         return { ...NOT_PRIVILEGED, saved: false };
       }
       const entry = memory.addMemory({
@@ -418,7 +579,8 @@ const TOOLS = {
         },
       },
     },
-    describe: () => "🧠 بدور في الذاكرة...",
+    describe: () => "🧠 جاري البحث في الذاكرة...",
+    describeEn: () => "🧠 Searching memory...",
     async run(args, ctx) {
       const wanted = String(args?.scope || "chat").toLowerCase();
       const scopes = wanted === "all" ? ["chat", "global"] : [scopeOf(args)];
@@ -449,10 +611,12 @@ const TOOLS = {
         required: ["ref"],
       },
     },
-    describe: (args) => `🗑️ بمسح من الذاكرة: ${preview(args?.ref)}`,
+    describe: (args) => `🗑️ جاري الحذف من الذاكرة: ${preview(args?.ref)}`,
+    describeEn: (args) => `🗑️ Removing from memory: ${preview(args?.ref)}`,
     async run(args, ctx) {
-      if (!isPrivileged(ctx)) return { ...NOT_PRIVILEGED, removed: false };
       const scope = scopeOf(args);
+      const allowed = scope === "global" ? isBotPrivileged(ctx) : isChatMemoryAdmin(ctx);
+      if (!allowed) return { ...NOT_PRIVILEGED, removed: false };
       const removed = memory.removeMemory({
         scope,
         chatId: ctx.chatId,
@@ -483,18 +647,24 @@ const TOOLS = {
       },
     },
     describe: (args) =>
-      `🔑 ببص على صلاحيات: ${preview(args?.target, 25)} (${args?.role || "admin"})`,
+      `🔑 جاري فحص صلاحيات: ${preview(args?.target, 25)} (${args?.role || "admin"})`,
+    describeEn: (args) =>
+      `🔑 Checking permissions: ${preview(args?.target, 25)} (${args?.role || "admin"})`,
     async run(args, ctx) {
       if (!ctx.isOwner) {
         return { error: "only the bot owner can grant roles", granted: false };
       }
-      const role = String(args?.role || "admin").toLowerCase() === "owner"
-        ? "owner"
-        : "admin";
+      if (!roleTargetBound(args?.target, ctx)) {
+        return {
+          error: "mention, quote, or type the target phone number in your own request",
+          granted: false,
+        };
+      }
+      const role = String(args?.role || "admin").toLowerCase() === "owner" ? "owner" : "admin";
       const record = await grantRole(args?.target, role);
       logger.info(
         { target: args?.target, role, by: ctx.senderId },
-        "[aiTools] role granted by the agent"
+        "[aiTools] role granted by the agent",
       );
       return {
         granted: true,
@@ -517,14 +687,19 @@ const TOOLS = {
         required: ["target"],
       },
     },
-    describe: (args) => `🔑 بسحب صلاحية من: ${preview(args?.target, 25)}`,
+    describe: (args) => `🔑 جاري سحب الصلاحية من: ${preview(args?.target, 25)}`,
+    describeEn: (args) => `🔑 Revoking permissions from: ${preview(args?.target, 25)}`,
     async run(args, ctx) {
       if (!ctx.isOwner) {
         return { error: "only the bot owner can revoke roles", revoked: false };
       }
-      const role = String(args?.role || "admin").toLowerCase() === "owner"
-        ? "owner"
-        : "admin";
+      if (!roleTargetBound(args?.target, ctx)) {
+        return {
+          error: "mention, quote, or type the target phone number in your own request",
+          revoked: false,
+        };
+      }
+      const role = String(args?.role || "admin").toLowerCase() === "owner" ? "owner" : "admin";
       const record = await revokeRole(args?.target, role);
       return { revoked: true, role, user: record ? record.jid : args?.target };
     },
@@ -533,11 +708,11 @@ const TOOLS = {
   list_roles: {
     declaration: {
       name: "list_roles",
-      description:
-        "List who currently holds bot owner / admin roles. Owners and admins only.",
+      description: "List who currently holds bot owner / admin roles. Owners and admins only.",
       parameters: { type: T.OBJECT, properties: {} },
     },
-    describe: () => "🔑 بجيب قائمة الصلاحيات...",
+    describe: () => "🔑 جاري جلب قائمة الصلاحيات...",
+    describeEn: () => "🔑 Fetching roles list...",
     async run(_args, ctx) {
       if (!ctx.isOwner && !ctx.isAdmin) {
         return { error: "only owners and admins can list roles" };
@@ -567,7 +742,8 @@ const TOOLS = {
         },
       },
     },
-    describe: () => "🕒 بشوف الوقت...",
+    describe: () => "🕒 جاري التحقق من الوقت الحالي...",
+    describeEn: () => "🕒 Checking current time...",
     async run(args) {
       const timeZone = args?.timezone || settings.get("bot_timezone");
       const now = new Date();
@@ -596,13 +772,18 @@ function toolDeclarations() {
 }
 
 /** The status line for a tool call (falls back to the raw name). */
-function describeCall(name, args) {
+function describeCall(name, args, lang = settings.get("bot_language")) {
   const tool = TOOLS[name];
-  if (!tool) return `⚙️ بشغّل: ${name}`;
+  const isEn = lang === "en";
+  const fallback = isEn ? `⚙️ Running: ${name}` : `⚙️ جاري تشغيل: ${name}`;
+  if (!tool) return fallback;
   try {
-    return tool.describe(args) || `⚙️ بشغّل: ${name}`;
+    if (isEn && typeof tool.describeEn === "function") {
+      return tool.describeEn(args) || fallback;
+    }
+    return tool.describe(args) || fallback;
   } catch {
-    return `⚙️ بشغّل: ${name}`;
+    return fallback;
   }
 }
 
@@ -618,10 +799,7 @@ async function runTool(name, args, ctx) {
     const result = await tool.run(args || {}, ctx || {});
     return result && typeof result === "object" ? result : { result };
   } catch (err) {
-    logger.warn(
-      { err: err?.message, tool: name },
-      "[aiTools] tool call failed"
-    );
+    logger.warn({ err: err?.message, tool: name }, "[aiTools] tool call failed");
     return { error: `${err?.name || "Error"}: ${err?.message || err}` };
   }
 }
@@ -632,6 +810,8 @@ module.exports = {
   describeCall,
   runTool,
   webSearch,
+  searchNews,
+  searchWikipedia,
   fetchUrl,
   decodeText,
 };