levix-bot 2.2.0 → 2.3.0

package/README.md

@@ -1,125 +1,196 @@
-# Levix
+<p align="center">
+  <img src="public/brand/banner.webp" alt="Levix - Personal WhatsApp Bot" width="100%">
+</p>
+
+<p align="center">
+  <a href="https://github.com/Abdodiab2005/levix/actions/workflows/ci.yml"><img src="https://github.com/Abdodiab2005/levix/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://www.npmjs.com/package/levix-bot"><img src="https://img.shields.io/npm/v/levix-bot?color=2563eb" alt="npm version"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-10b981" alt="MIT License"></a>
+  <img src="https://img.shields.io/badge/Node.js-24%2B-339933?logo=nodedotjs&logoColor=white" alt="Node.js 24+">
+</p>
+
+<p align="center">
+  <strong>Free, open-source, self-hosted WhatsApp automation that stays under your control.</strong>
+</p>
+
+<p align="center">
+  <a href="https://levix.leviro.net">Website</a> ·
+  <a href="SETUP.md">Setup guide</a> ·
+  <a href="https://github.com/Abdodiab2005/levix/releases/latest">Downloads</a> ·
+  <a href="https://github.com/Abdodiab2005/levix/issues">Issues</a>
+</p>
+
+Levix is a personal WhatsApp bot with 55 commands, group moderation, scheduled
+messages, an AI agent, media tools, and a web control panel. You run it on your
+own computer or server, keep its database and session files yourself, and can
+change almost everything while it is running.
+
+There is no paid tier, hosted account, external database, or configuration file
+to maintain. Levix is released under the MIT License.
+
+> [!WARNING]
+> Levix uses [Baileys](https://github.com/WhiskeySockets/Baileys), an unofficial
+> WhatsApp Web client, and is not affiliated with or endorsed by WhatsApp or
+> Meta. Unofficial automation can lead to temporary restrictions or an account
+> ban. Do not use Levix for spam or unsolicited bulk messaging. If an outage or
+> account restriction is unacceptable, use the official WhatsApp Business
+> Platform instead.
+
+## Quick start
+
+### Linux server
+
+The public installer installs the latest stable release and configures Levix as
+a service:
 
-A self-hosted personal WhatsApp bot: 55 commands, group moderation, an AI agent
-on Google Gemini, scheduled messages, and a web control panel that can change
-almost all of it while the bot runs.
+```bash
+curl -fsSL https://levix.leviro.net/install.sh | bash
+```
+
+You can [read the installer](deploy/install.sh) before running it.
 
-Built by Abdelrhman Diab (Leviro).
+### npm
+
+Requires Node.js 24 or newer:
 
 ```bash
 npm install -g levix-bot
 levix
 ```
 
-The npm package is named `levix-bot`; the installed CLI command stays `levix`.
+### Docker
 
-On a desktop that opens the panel in your browser by itself. Pick a password,
-go to **Connection**, press **Start session** and scan the QR — see
-[SETUP.md](SETUP.md) for the longer version, Docker, and running it as a
-service.
+```bash
+git clone https://github.com/Abdodiab2005/levix
+cd levix
+docker compose up -d
+docker compose logs levix
+```
 
-Starting Levix does not connect it to WhatsApp. The panel, the database and the
-commands come up on their own, and the WhatsApp session is started from the
-Connection screen when you want it.
+Standalone Linux, macOS ARM64, and Windows binaries are available from the
+[latest GitHub release](https://github.com/Abdodiab2005/levix/releases/latest).
 
-```
-  levix                    start Levix with the web panel
-  levix headless           start Levix with no web UI at all
-  levix where              print the data directory
-  levix reset-password     reset the panel password
-  levix domain [name]      point a domain at Levix (may need sudo)
-```
+When Levix starts:
 
----
+1. Open the panel URL printed in the terminal.
+2. Choose a panel password. A remote first-time setup also asks for the printed
+   setup code.
+3. Open **Connection**, press **Start session**, and scan the QR from WhatsApp.
+4. Send `!ping` in a chat.
 
-## What it does
+A successfully linked WhatsApp session resumes automatically after a process,
+Docker, or systemd restart. See [SETUP.md](SETUP.md) for domains, reverse
+proxies, headless mode, backups, and troubleshooting.
 
-**Commands** — `!ping`, `!help`, `!calc`, `!poll`, `!rand`, `!loop`, `!todo`,
-`!notes`, `!debt`, `!weather`, `!prayer`, `!tts`, `!stt`, `!shortlink`,
-`!qr`, `!score`… every one of them can be renamed, re-permissioned or turned
-off from the panel.
+## What you get
 
-**Group moderation** — welcome messages, anti-link, anti-spam, media rules,
-warnings with auto-kick, rules and notes, plus the usual `!group kick`,
-`promote`, `demote`, `add`, `tagadmins`.
+| Area | What Levix provides |
+| --- | --- |
+| Commands | 55 commands for utilities, notes, reminders, polls, media, speech, weather, prayer times, and more |
+| Group moderation | Welcome messages, anti-link, anti-spam, media rules, warnings, auto-kick, roles, rules, and notes |
+| AI agent | Pick Google Gemini, OpenAI / any OpenAI-compatible server, or Anthropic from the panel; each provider has its own endpoint, API key, and model, with tools for web search, page reading, memory, and role management |
+| Scheduling | One-off, daily, and weekly messages with durable jobs, delivery status, and manual retry |
+| Control panel | Live connection state, command settings, roles, permissions, keys, memory, schedules, and logs |
+| Media | Text, images, video, audio, QR codes, text-to-speech, and speech-to-text |
+| Deployment | npm, Docker, systemd installer, standalone binaries, headless mode, and safe domain setup |
+| Storage | One SQLite database and one data directory for settings, sessions, memory, and logs |
 
-**An AI agent, not a chat box** — `!gemini` can search the web, open a page and
-read it, save something to its long-term memory and hand out bot roles, across
-several tool rounds, narrating the whole run inside a single message it keeps
-editing. Gemini's own Google Search is available to it too, so questions about
-current things get grounded answers with their sources listed. Its personality
-is a Markdown file you can edit from the panel.
+Every command can be enabled, disabled, renamed, and assigned permissions from
+the panel without restarting the bot.
 
-**Long-term memory** — "remember that…" writes to `memory/global.md` or a
-per-chat file. Plain Markdown, hand-editable, injected into every prompt.
+### AI that can act
 
-**Scheduled messages** — one-off (`!schedule`) or recurring (`!autoschedule`),
-including daily and weekly schedules with Arabic or English day names. Jobs
-survive restarts; their latest delivery result is shown in the panel, where a
-failed message can be retried manually.
+The `!gemini` command is an agent rather than a plain chat box. It can run
+several tool rounds, search the web, read a page, save long-term memories, and
+manage bot roles. It narrates progress by editing one WhatsApp message and lists
+sources when it uses web search.
 
-**Optional proxy** — Settings → WhatsApp proxy routes the WhatsApp connection
-through an HTTP, HTTPS or SOCKS5 proxy, including the media it sends and
-receives. Nothing else changes: the control panel and the AI still connect
-directly.
+AI is optional. The rest of Levix works without an AI key.
 
-**A connection you control** — the panel starts, stops and unlinks the
-WhatsApp session, and shows what it is actually doing: waiting for a scan,
-connected, reconnecting (5s, 10s, 15s, 20s, 25s), or stopped. Reconnects happen
-in the bot whether or not a browser is open, and a WhatsApp connection that will
-not come back never takes the panel down with it.
+### Persistent schedules and memory
 
-**A panel you can also do without** — `levix headless` runs the bot with no
-Express, no socket.io and no port open at all; having no screen to press Start
-on, it connects by itself and prints its QR straight to the terminal.
+One-off and recurring schedules survive restarts and record their latest
+delivery outcome. Long-term memory is stored as plain Markdown in
+`memory/global.md` or per-chat files, so it remains readable and editable
+outside the panel.
 
-**A domain, without a takeover** — `levix domain bot.example.com` looks at what
-the server already runs and works with it: it adds one nginx or Caddy site and
-validates the whole configuration before reloading, and on a panel-managed or
-containerised host it changes nothing and prints the exact reverse-proxy
-settings instead.
+### A connection you control
 
----
+The panel can start, stop, reconnect, and unlink WhatsApp while showing the
+actual state: idle, waiting for a scan, connected, reconnecting, or stopped.
+Reconnect attempts continue inside the bot even when no browser is open.
 
-## How it is put together
+An optional HTTP, HTTPS, or SOCKS5 proxy can route WhatsApp traffic, including
+media, without changing how the panel or AI connects.
 
-- **Node 24+**, ES modules and CommonJS side by side (see `CLAUDE.md`).
-- **[Baileys v7](https://github.com/WhiskeySockets/Baileys)** for WhatsApp,
-  including the LID system.
-- **SQLite through `node:sqlite`** — Node's own module, so the whole datastore
-  is one file and zero dependencies. No database server, nothing to compile.
-- **Express + EJS** for the panel. No framework, no CDN, no build step.
-- **Google Gemini** for the AI, with an optional Groq fallback.
+## CLI
 
-Three things follow from that, and they are the point of the design:
+```text
+levix                    start Levix with the web panel
+levix headless           start Levix with no web UI or open port
+levix where              print the data directory
+levix reset-password     reset the panel password
+levix domain [name]      configure a domain safely (may need sudo)
+```
+
+A fresh panel install waits for you to start the first WhatsApp pairing.
+`levix headless` has no button to press, so it starts the session itself and
+prints the QR in the terminal when needed.
+
+## Data and configuration
+
+Everything mutable lives in one data directory:
+
+- npm installation: `~/.levix`
+- source checkout: `./data`
+- Docker: the `levix-data` volume
 
-**The database is the source of truth, the panel is how you edit it.** There is
-no `.env` file and no config file — the prefix, every permission, every API key
-and every tuning value is a row in `bot_settings`, and every read goes through
-an accessor at call time so a change applies to the next message.
+Copying this directory is a full backup, including the SQLite database, WhatsApp
+session, memory, and logs.
 
-**Secrets are generated, not configured.** The session signing key is made on
-first start. The panel password is chosen once, in the browser, and stored as
-an scrypt hash.
+The database is the source of truth. The prefix, permissions, API keys, server
+settings, and feature options are stored in `bot_settings` and read at use
+time. There is no `.env` or application configuration file to keep in sync.
 
-**Everything mutable lives in one directory** — database, WhatsApp session,
-memory files, logs. `levix where` prints it; copying it is a full backup.
+Secrets are generated rather than shipped with defaults. The panel password is
+stored as an scrypt hash, and the session-signing key is generated on first
+start.
 
----
+## Architecture
 
-## For developers
+- **Node.js 24+** with ES modules and CommonJS where needed.
+- **Baileys v7** for the WhatsApp connection and LID support.
+- **`node:sqlite`** for a single-file datastore with no database server or
+  native SQLite dependency.
+- **Express + EJS** for a panel with no frontend build step or CDN dependency.
+- **Pluggable AI providers** — Google Gemini, OpenAI / any OpenAI-compatible endpoint, or
+  Anthropic — each with its own endpoint, API key, and model in the control panel, no env file.
+- **GitHub Actions** validation for tests, npm packaging, Docker persistence,
+  and standalone executables on Linux, macOS, and Windows.
+
+[AGENTS.md](AGENTS.md) documents the module layout, message flow, storage API,
+and architectural constraints. [PACKAGING.md](PACKAGING.md) covers npm, Docker,
+systemd, installers, and single-executable releases.
+
+## Development
 
 ```bash
 git clone https://github.com/Abdodiab2005/levix
 cd levix
-npm install
-npm start          # data lands in ./data
+npm ci
+npm test
+npm start
 ```
 
-`CLAUDE.md` is the architecture document: module layout, the storage API, the
-message flow, and the rules a change has to respect. `PACKAGING.md` covers
-shipping it — npm, Docker, systemd, and the single-executable build.
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) before proposing a substantial
+change. Bug reports and focused pull requests are welcome.
+
+For security issues, follow [SECURITY.md](SECURITY.md) and report them
+privately rather than opening a public issue.
 
 ## License
 
-MIT.
+Levix is free and open source under the [MIT License](LICENSE).
+
+Built by [Abdelrhman Diab](https://github.com/Abdodiab2005) under
+[Leviro](https://leviro.net).

package/SETUP.md

@@ -58,9 +58,14 @@ The terminal prints something like:
    bot before you do.)
 3. You land on the control panel. Go to **Connection**, press **Start session**,
    and scan the QR with WhatsApp → Settings → Linked devices → Link a device.
-   Levix does not connect to WhatsApp until you ask it to.
+   A brand-new install does not begin pairing until you press Start.
 4. Send `!ping` in any chat. The bot answers.
 
+After that first successful pairing, the saved WhatsApp session resumes
+automatically after a Levix, Docker or systemd restart. You only need the
+Connection screen again if you deliberately stop/unlink the session or WhatsApp
+requires a new link.
+
 Levix only opens a browser when there is one to open: over SSH, under systemd,
 in Docker or in CI it just prints the address and says why. `--no-open` turns
 it off anywhere.
@@ -85,7 +90,8 @@ Then open <http://localhost:3001>. The setup code is in the logs:
 docker compose logs levix | grep -F '[Setup] Setup code:' | tail -1
 ```
 
-Everything the bot owns lives in the `levix-data` volume.
+Everything the bot owns lives in the `levix-data` volume. Once WhatsApp has
+been paired, restarting the container reuses that saved session automatically.
 
 ---
 
@@ -181,11 +187,11 @@ journalctl -u levix --no-pager | grep -F '[Setup] Setup code:' | tail -1
 
 Read the script first if you like — it is short, and it explains each step.
 
-That always installs the newest stable Levix. To stay on one version — the same
-script, pinned — use its own URL:
+That always installs the newest stable Levix. To stay on this release — the
+same script, pinned — use its own URL:
 
 ```bash
-curl -fsSL https://levix.leviro.net/install/v2.0.0.sh | bash
+curl -fsSL https://levix.leviro.net/install/v2.2.1.sh | bash
 ```
 
 **Behind a proxy** — if this server reaches the internet through a proxy, the

package/app.cjs

@@ -19,6 +19,7 @@ const { assetPath } = require("./src/config/paths.cjs");
 const brand = require("./src/config/brand.cjs");
 const settings = require("./src/config/settings.cjs");
 const secrets = require("./src/config/secrets.cjs");
+const { PanelSessionStore } = require("./src/panel/session-store.cjs");
 const { getQrCode } = require("./src/utils/storage.cjs");
 const {
   clientAddress,
@@ -151,9 +152,14 @@ app.locals.brand = brand;
 app.use(express.static(assetPath("public")));
 app.use(express.urlencoded({ extended: true, limit: "100kb" }));
 
+// Levix is intentionally one process and one operator, so a small expiring
+// in-memory store is enough. Unlike express-session's development MemoryStore,
+// it is explicitly bounded and prunes expired entries instead of growing for
+// the lifetime of the process. Sessions still disappear on restart by design.
 const sessionMiddleware = session({
   name: SESSION_COOKIE_NAME,
   secret: secrets.getSessionSecret(),
+  store: new PanelSessionStore({ ttlMs: SESSION_MAX_AGE_MS }),
   resave: false,
   saveUninitialized: false,
   cookie: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "levix-bot",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "A self-hosted personal WhatsApp bot with an AI agent, group moderation and a web control panel.",
   "main": "src/index.js",
   "scripts": {
@@ -18,6 +18,9 @@
     "bot",
     "baileys",
     "gemini",
+    "openai",
+    "anthropic",
+    "openai-compatible",
     "ai-agent",
     "sqlite",
     "self-hosted"
@@ -57,7 +60,7 @@
     "type": "git",
     "url": "https://github.com/Abdodiab2005/levix.git"
   },
-  "homepage": "https://github.com/Abdodiab2005/levix",
+  "homepage": "https://levix.leviro.net",
   "bugs": {
     "url": "https://github.com/Abdodiab2005/levix/issues"
   },

package/public/dashboard.js

@@ -1167,7 +1167,7 @@
             ${setting.choices
               .map(
                 (choice) =>
-                  `<option value="${esc(choice)}"${choice === setting.value ? " selected" : ""}>${esc(choice)}</option>`
+                  `<option value="${esc(choice)}"${choice === setting.value ? " selected" : ""}>${esc(setting.choiceLabels?.[choice] || choice)}</option>`
               )
               .join("")}
           </select>

package/src/commands/gemini.cjs

@@ -6,8 +6,12 @@
 //   * the multi-message context buffer (`!gemini add` ... `!gemini send`),
 //   * image generation (`!generate`),
 //   * memory management shortcuts (`!del`, `!delall`),
-//   * the fallbacks: sanitize-and-retry when an uploaded file URI expired, and
-//     Groq when Gemini is rate limited.
+//   * the fallback: sanitize-and-retry when an uploaded file URI expired.
+//
+// The active provider itself (gemini / openai / anthropic) is a setting, and
+// the loop it dispatches to lives in services/aiAgent.cjs +
+// services/aiProviders.cjs. Media and !generate/!stt stay Gemini-only — the
+// other providers have no Files API to upload to.
 //
 // What moved out:
 //   * the system prompt          -> config/ai-persona.md (editable, hot-reloaded)
@@ -21,7 +25,6 @@
 const { GoogleGenAI } = require("@google/genai");
 
 const logger = require("../utils/logger.cjs");
-const aiIdentity = require("../config/ai-identity.cjs");
 const settings = require("../config/settings.cjs");
 const {
   getChatHistoryAsync,
@@ -41,6 +44,7 @@ const {
   formatSources,
   isFileReferenceError,
   sanitizeHistoryForFiles,
+  activeProviderKeySetting,
 } = require("../services/aiAgent.cjs");
 const { downloadContentFromMessage } = require("@whiskeysockets/baileys");
 const fs = require("fs").promises;
@@ -69,79 +73,34 @@ function setBuffer(msg, entries) {
 // One client does everything now: @google/genai folded the separate
 // GoogleAIFileManager into `ai.files`, and the model is named per request
 // instead of being baked into a model object.
-let geminiCache = { key: null, genAI: null };
+let geminiCache = { key: null, baseUrl: null, genAI: null };
 
 function geminiClients() {
   const key = settings.get("gemini_api_key");
   if (!key) return { genAI: null };
-  if (geminiCache.key !== key) {
-    geminiCache = { key, genAI: new GoogleGenAI({ apiKey: key }) };
+  const baseUrl = String(settings.get("gemini_base_url")).replace(/\/+$/, "");
+  if (geminiCache.key !== key || geminiCache.baseUrl !== baseUrl) {
+    geminiCache = {
+      key,
+      baseUrl,
+      genAI: new GoogleGenAI({ apiKey: key, httpOptions: { baseUrl } }),
+    };
   }
   return geminiCache;
 }
 
-function isGeminiRateLimitError(error) {
-  const message = `${error?.message || ""} ${error?.details || ""}`.toLowerCase();
-  // @google/genai's ApiError carries a numeric `status`; the older shapes are
-  // kept because they cost nothing and a queued error can predate an upgrade.
-  const status =
-    error?.status ||
-    error?.statusCode ||
-    error?.code ||
-    error?.response?.status ||
-    error?.error?.code;
-
-  return (
-    status === 429 ||
-    message.includes("429") ||
-    message.includes("rate limit") ||
-    message.includes("resource_exhausted") ||
-    message.includes("quota")
-  );
-}
-
-async function getGroqFallbackResponse(parts) {
-  const groqKey = settings.get("groq_api_key");
-  if (!groqKey) throw new Error("GROQ_API_KEY is not configured");
-
-  const mergedPrompt = parts
-    .map((part) => {
-      if (part?.text) return part.text;
-      if (part?.fileData) return "[تم إرفاق ملف/وسائط في الرسالة]";
-      return "";
-    })
-    .filter(Boolean)
-    .join("\n");
-
-  const response = await fetch("https://api.groq.com/openai/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${groqKey}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      model: settings.get("groq_model"),
-      messages: [
-        {
-          role: "system",
-          // Same code-owned identity the Gemini path gets — the fallback must
-          // not answer "who made you?" differently from the main model.
-          content: `${aiIdentity.systemBlock}\n\nBe brief, direct and conversational. Answer in the language the user wrote in.`,
-        },
-        { role: "user", content: mergedPrompt },
-      ],
-      temperature: 0.7,
-    }),
-  });
-
-  const payload = await response.json();
-  if (!response.ok) {
-    throw new Error(payload?.error?.message || "Groq API request failed");
+async function processIncomingMedia(parts, mediaMessage, mimeOverride = null) {
+  // Reading media is a Gemini capability: the Files API it uploads to does not
+  // exist on the openai/anthropic paths. There the turn carries a note and the
+  // caption/question text still reaches the model.
+  if (settings.get("ai_provider") !== "gemini") {
+    const mime = mimeOverride || mediaMessage.mimetype || "ملف";
+    parts.push({
+      text: `[تم إرفاق وسائط (${mime}) — المزود الحالي لا يستطيع قراءة الوسائط]`,
+    });
+    return null;
   }
-  return payload?.choices?.[0]?.message?.content?.trim();
-}
 
-async function processIncomingMedia(parts, mediaMessage, mimeOverride = null) {
   const { genAI } = geminiClients();
   if (!genAI) throw new Error("Gemini client unavailable");
   const tempFilePath = path.join(__dirname, `temp_media_${Date.now()}`);
@@ -392,6 +351,14 @@ module.exports = {
       );
 
       try {
+        // Image generation needs a model that returns image bytes, which only
+        // the Gemini image models do — it stays on Gemini whatever the chat
+        // provider is.
+        if (!geminiClients().genAI) {
+          throw new Error(
+            "مفتاح Gemini API غير معرف — توليد الصور يعمل على Gemini فقط"
+          );
+        }
         const fullPrompt =
           imagePrompt && quotedMsg
             ? `Prompt: ${imagePrompt} ,using quote: ${quotedMsg}`
@@ -636,11 +603,16 @@ module.exports = {
       }
     }
 
-    if (!geminiClients().genAI) {
+    // Provider-aware, on purpose: when the panel picked openai or anthropic,
+    // the bot answers with that key and a missing Gemini key is irrelevant.
+    if (!settings.get(activeProviderKeySetting())) {
+      const provider = settings.get("ai_provider");
       return sendBotMessage(
         sock,
         chatId,
-        { text: "خطأ في الإعدادات: مفتاح Gemini API غير معرف." },
+        {
+          text: `خطأ في الإعدادات: مفتاح مزود الذكاء الاصطناعي الحالي (${provider}) غير معرف — عدّله من لوحة التحكم.`,
+        },
         { replyTo: msg }
       );
     }
@@ -718,26 +690,6 @@ module.exports = {
       await status.finish(`${text}${formatSources(result.sources)}`);
     } catch (error) {
       logger.error({ err: error }, "Error in !gemini command");
-
-      // Rate-limit fallback to Groq for text-only prompts.
-      if (isGeminiRateLimitError(error) && settings.get("groq_api_key")) {
-        if (parts.some((part) => part?.fileData)) {
-          await status.finish(
-            "جيميني عليه ضغط حالياً، ومش قادر أعالج الوسائط دلوقتي. حاول بعد شوية 🙏"
-          );
-          return;
-        }
-        try {
-          const groqResponse = await getGroqFallbackResponse(parts);
-          if (groqResponse) {
-            await status.finish(groqResponse);
-            return;
-          }
-        } catch (groqError) {
-          logger.error({ err: groqError }, "Groq fallback failed");
-        }
-      }
-
       await status.fail(error, "حصلت مشكلة وأنا بكلم الذكاء الاصطناعي");
     }
   },

package/src/commands/stt.cjs

@@ -13,13 +13,18 @@ const settings = require("../config/settings.cjs");
 //
 // One @google/genai client covers both halves: `ai.files` replaced the separate
 // GoogleAIFileManager, and the model is named per request.
-let cache = { key: null, genAI: null };
+let cache = { key: null, baseUrl: null, genAI: null };
 
 function geminiStt() {
   const key = settings.get("gemini_api_key");
   if (!key) return null;
-  if (cache.key !== key) {
-    cache = { key, genAI: new GoogleGenAI({ apiKey: key }) };
+  const baseUrl = String(settings.get("gemini_base_url")).replace(/\/+$/, "");
+  if (cache.key !== key || cache.baseUrl !== baseUrl) {
+    cache = {
+      key,
+      baseUrl,
+      genAI: new GoogleGenAI({ apiKey: key, httpOptions: { baseUrl } }),
+    };
   }
   return cache;
 }