npm - @polderlabs/bizar - Versions diffs - 4.4.11 → 4.4.12 - Mend

@polderlabs/bizar 4.4.11 → 4.4.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/bizar-dash/dist/assets/{main-Nq8Dq3VR.css → main-BKXEqU1w.css} +1 -1
package/bizar-dash/dist/assets/main-EK_fzXn_.js +352 -0
package/bizar-dash/dist/assets/main-EK_fzXn_.js.map +1 -0
package/bizar-dash/dist/assets/mobile-Dl1q7Cyq.js.map +1 -1
package/bizar-dash/dist/index.html +2 -2
package/bizar-dash/src/server/api.mjs +2 -0
package/bizar-dash/src/server/minimax.mjs +352 -0
package/bizar-dash/src/server/routes/_shared.mjs +15 -0
package/bizar-dash/src/server/routes/minimax.mjs +140 -0
package/bizar-dash/src/web/App.tsx +2 -0
package/bizar-dash/src/web/components/Topbar.tsx +2 -0
package/bizar-dash/src/web/lib/types.ts +12 -0
package/bizar-dash/src/web/main.tsx +1 -0
package/bizar-dash/src/web/styles/minimax-usage.css +371 -0
package/bizar-dash/src/web/views/MiniMaxUsage.tsx +543 -0
package/package.json +1 -1
package/bizar-dash/dist/assets/main-CEazNxxy.js +0 -347
package/bizar-dash/dist/assets/main-CEazNxxy.js.map +0 -1

package/bizar-dash/dist/index.html CHANGED Viewed

@@ -29,10 +29,10 @@
         }
       })();
     </script>
-    <script type="module" crossorigin src="/assets/main-CEazNxxy.js"></script>
+    <script type="module" crossorigin src="/assets/main-EK_fzXn_.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/mobile-Dl1q7Cyq.js">
     <link rel="stylesheet" crossorigin href="/assets/mobile-CsZQAswA.css">
-    <link rel="stylesheet" crossorigin href="/assets/main-Nq8Dq3VR.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-BKXEqU1w.css">
   </head>
   <body>
     <div id="root"></div>

package/bizar-dash/src/server/api.mjs CHANGED Viewed

@@ -48,6 +48,7 @@ import { createDiagnosticsRouter } from './routes/diagnostics.mjs';
 import { createPairRouter } from './routes/pair.mjs';
 import { createThemesRouter } from './routes/themes.mjs';
 import { createNotificationsRouter } from './routes/notifications.mjs';
+import { createMinimaxRouter } from './routes/minimax.mjs';
 import { createMiscRouter } from './routes/misc.mjs';
 /**
@@ -118,6 +119,7 @@ export async function createApiRouter({
   router.use(createThemesRouter({ state }));
   router.use(createNotificationsRouter({ broadcast }));
   router.use(createArtifactsRouter({ state, broadcast, projectRoot }));
+  router.use(createMinimaxRouter({ state, broadcast }));
   router.use(createMiscRouter({ state, broadcast }));
   // /api/auth/* must be reachable WITHOUT the bearer token so a fresh

package/bizar-dash/src/server/minimax.mjs ADDED Viewed

@@ -0,0 +1,352 @@
+/**
+ * src/server/minimax.mjs
+ *
+ * v4.5.0 — MiniMax API client.
+ *
+ * Owns the network calls to platform.minimax.io for the Bizar
+ * dashboard. Two surfaces:
+ *
+ *  1. fetchRemains()  — the public `/v1/token_plan/remains` endpoint.
+ *     Returns the user's remaining Token Plan quota per model — both
+ *     5-hour rolling window and weekly window — including the reset
+ *     times for each. This is the headline data the user wants to see.
+ *
+ *  2. chatCompletion() — a thin wrapper around `/v1/chat/completions`
+ *     (OpenAI-compatible) for the dashboard's "Send a test prompt"
+ *     button. Also captures the `usage` block from the response so the
+ *     dashboard can show per-call consumption.
+ *
+ * The client always reads the API key from the user's settings
+ * (settings.minimax.apiKey) and never logs it. The base URL is
+ * configurable but defaults to `https://www.minimax.io` per the docs.
+ *
+ * Token Plan endpoints live on `www.minimax.io` (NOT `api.minimax.io`
+ * — the chat completions endpoint uses that one). The default
+ * `baseUrl` in the settings uses the Token Plan host so `fetchRemains`
+ * works out of the box.
+ *
+ * All network calls are guarded by a 10s timeout so a hung API
+ * never wedges the dashboard.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+const HOME = homedir();
+const BIZAR_HOME = join(HOME, '.config', 'bizar');
+const CACHE_DIR = join(BIZAR_HOME, 'minimax');
+const CACHE_FILE = join(CACHE_DIR, 'remains-cache.json');
+// Default base URL. The docs say `https://www.minimax.io/v1/token_plan/remains`
+// (note: the `www` host, not `api`). Allow override per-user in settings.
+export const DEFAULT_BASE_URL = 'https://www.minimax.io';
+// Chat completions / OpenAI-style surface lives on api.minimax.io.
+export const DEFAULT_CHAT_BASE_URL = 'https://api.minimax.io/v1';
+// Models Bizar exposes by default in the dashboard.
+export const KNOWN_MODELS = [
+  'MiniMax-M3',
+  'MiniMax-M2.7',
+  'MiniMax-M2.5',
+  'MiniMax-M2.1',
+  'MiniMax-M2',
+];
+/**
+ * Read the merged settings.json and return the MiniMax config block.
+ * Never throws — returns sane defaults on parse failure.
+ */
+export function readMinimaxSettings() {
+  const file = join(BIZAR_HOME, 'settings.json');
+  if (!existsSync(file)) {
+    return defaultMinimaxSettings();
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    const m = parsed.minimax;
+    if (!m || typeof m !== 'object') return defaultMinimaxSettings();
+    return {
+      enabled: m.enabled !== false,
+      apiKey: typeof m.apiKey === 'string' ? m.apiKey : '',
+      groupId: typeof m.groupId === 'string' ? m.groupId : 'default',
+      baseUrl: typeof m.baseUrl === 'string' ? m.baseUrl : DEFAULT_BASE_URL,
+      chatBaseUrl: typeof m.chatBaseUrl === 'string' ? m.chatBaseUrl : DEFAULT_CHAT_BASE_URL,
+    };
+  } catch {
+    return defaultMinimaxSettings();
+  }
+}
+export function defaultMinimaxSettings() {
+  return {
+    enabled: true,
+    apiKey: '',
+    groupId: 'default',
+    baseUrl: DEFAULT_BASE_URL,
+    chatBaseUrl: DEFAULT_CHAT_BASE_URL,
+  };
+}
+// ─── Cache (in-memory + disk) ──────────────────────────────────────────────
+/**
+ * In-memory snapshot of the last remains response. Avoids re-hitting the
+ * API on every dashboard render.
+ */
+let memoryCache = null;
+function readDiskCache() {
+  try {
+    if (!existsSync(CACHE_FILE)) return null;
+    const stat = require('node:fs').statSync(CACHE_FILE);
+    if (Date.now() - stat.mtimeMs > 5 * 60 * 1000) return null; // 5 min TTL
+    return JSON.parse(readFileSync(CACHE_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function writeDiskCache(snapshot) {
+  try {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(CACHE_FILE, JSON.stringify(snapshot, null, 2) + '\n', 'utf8');
+  } catch {
+    /* best-effort */
+  }
+}
+export function clearRemainsCache() {
+  memoryCache = null;
+  try {
+    if (existsSync(CACHE_FILE)) {
+      require('node:fs').unlinkSync(CACHE_FILE);
+    }
+  } catch { /* best-effort */ }
+}
+/**
+ * Try in-memory → disk cache. Returns the cached snapshot or null.
+ */
+export function readCachedRemains() {
+  if (memoryCache) return memoryCache;
+  const fromDisk = readDiskCache();
+  if (fromDisk) {
+    memoryCache = fromDisk;
+    return fromDisk;
+  }
+  return null;
+}
+// ─── Network helpers ──────────────────────────────────────────────────────
+/**
+ * Fetch with a hard timeout. Uses undici (Node 18+ global fetch is
+ * fine but AbortSignal.timeout is simpler with node:fetch).
+ */
+async function fetchWithTimeout(url, opts = {}, timeoutMs = 10_000) {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...opts, signal: ctl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+}
+// ─── Public API ────────────────────────────────────────────────────────────
+/**
+ * Hit /v1/token_plan/remains with the user's API key + group_id.
+ *
+ * Response shape:
+ *   {
+ *     model_remains: [
+ *       { model_name, current_interval_remaining_percent, current_weekly_remaining_percent,
+ *         start_time, end_time, remains_time, weekly_start_time, weekly_end_time,
+ *         weekly_remains_time, current_interval_total_count, current_interval_usage_count,
+ *         current_weekly_total_count, current_weekly_usage_count,
+ *         current_interval_status, current_weekly_status },
+ *       ...
+ *     ],
+ *     base_resp: { status_code, status_msg }
+ *   }
+ *
+ * Returns the raw response, augmented with `fetchedAt` and (if we got
+ * data) the per-model `endTimeISO` / `weeklyEndTimeISO` strings for
+ * convenient rendering in the UI.
+ */
+export async function fetchRemains({ apiKey, groupId = 'default', baseUrl = DEFAULT_BASE_URL, force = false } = {}) {
+  if (!apiKey || !apiKey.trim()) {
+    return { ok: false, error: 'no_api_key', message: 'MiniMax API key is not configured' };
+  }
+  if (!force) {
+    const cached = readCachedRemains();
+    if (cached && cached.apiKeyHint === maskKey(apiKey) && (Date.now() - cached.fetchedAt) < 60_000) {
+      return { ok: true, cached: true, ...cached };
+    }
+  }
+  const url = `${baseUrl.replace(/\/$/, '')}/v1/token_plan/remains?group_id=${encodeURIComponent(groupId)}`;
+  let resp;
+  try {
+    resp = await fetchWithTimeout(url, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+    });
+  } catch (err) {
+    return { ok: false, error: 'network_error', message: err.message || 'fetch failed' };
+  }
+  const text = await resp.text();
+  let body = null;
+  try { body = text ? JSON.parse(text) : null; } catch { /* keep as null */ }
+  if (!resp.ok) {
+    return {
+      ok: false,
+      error: `http_${resp.status}`,
+      message: body?.base_resp?.status_msg || resp.statusText || 'request failed',
+      status: resp.status,
+    };
+  }
+  if (!body || body.base_resp?.status_code !== 0) {
+    return {
+      ok: false,
+      error: 'api_error',
+      message: body?.base_resp?.status_msg || 'unknown error',
+      raw: body,
+    };
+  }
+  // Augment with ISO timestamps so the UI doesn't have to do ms → Date
+  // arithmetic for every cell.
+  const models = (body.model_remains || []).map((m) => ({
+    ...m,
+    endTimeISO: new Date(m.end_time).toISOString(),
+    weeklyEndTimeISO: new Date(m.weekly_end_time).toISOString(),
+    intervalResetInMs: m.remains_time,
+    weeklyResetInMs: m.weekly_remains_time,
+    intervalResetInHuman: humanizeDuration(m.remains_time),
+    weeklyResetInHuman: humanizeDuration(m.weekly_remains_time),
+    intervalConsumedPercent: clamp(100 - (m.current_interval_remaining_percent || 0), 0, 100),
+    weeklyConsumedPercent: clamp(100 - (m.current_weekly_remaining_percent || 0), 0, 100),
+    intervalUsed: m.current_interval_usage_count || 0,
+    intervalTotal: m.current_interval_total_count || 0,
+    weeklyUsed: m.current_weekly_usage_count || 0,
+    weeklyTotal: m.current_weekly_total_count || 0,
+  }));
+  const snapshot = {
+    ok: true,
+    fetchedAt: Date.now(),
+    apiKeyHint: maskKey(apiKey),
+    groupId,
+    baseUrl,
+    models,
+    baseResp: body.base_resp,
+  };
+  memoryCache = snapshot;
+  writeDiskCache(snapshot);
+  return snapshot;
+}
+/**
+ * Send a single chat-completion to /v1/chat/completions and return
+ * the parsed response + parsed `usage` block. Used by the dashboard's
+ * "Send a test prompt" button so the user can verify their key works
+ * and see live token usage.
+ */
+export async function chatCompletion({
+  apiKey,
+  prompt,
+  model = 'MiniMax-M3',
+  baseUrl = DEFAULT_CHAT_BASE_URL,
+  maxTokens = 256,
+} = {}) {
+  if (!apiKey || !apiKey.trim()) {
+    return { ok: false, error: 'no_api_key', message: 'MiniMax API key is not configured' };
+  }
+  if (!prompt || !prompt.trim()) {
+    return { ok: false, error: 'no_prompt', message: 'prompt is empty' };
+  }
+  const url = `${baseUrl.replace(/\/$/, '')}/chat/completions`;
+  const body = JSON.stringify({
+    model,
+    messages: [{ role: 'user', content: prompt }],
+    max_completion_tokens: maxTokens,
+    stream: false,
+  });
+  let resp;
+  try {
+    resp = await fetchWithTimeout(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+      body,
+    });
+  } catch (err) {
+    return { ok: false, error: 'network_error', message: err.message || 'fetch failed' };
+  }
+  const text = await resp.text();
+  let data = null;
+  try { data = text ? JSON.parse(text) : null; } catch { /* ignore */ }
+  if (!resp.ok) {
+    return {
+      ok: false,
+      error: `http_${resp.status}`,
+      message: data?.base_resp?.status_msg || resp.statusText || 'request failed',
+      status: resp.status,
+      raw: data,
+    };
+  }
+  if (!data || data.base_resp?.status_code !== 0) {
+    return {
+      ok: false,
+      error: 'api_error',
+      message: data?.base_resp?.status_msg || 'unknown error',
+      raw: data,
+    };
+  }
+  const choice = (data.choices || [])[0] || {};
+  const content = choice?.message?.content || '';
+  return {
+    ok: true,
+    model: data.model || model,
+    content,
+    reasoning: choice?.message?.reasoning_content || null,
+    finishReason: choice?.finish_reason || null,
+    usage: data.usage || null,
+    baseResp: data.base_resp,
+  };
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+/** Mask the API key for safe logging / display. Shows last 4 chars. */
+export function maskKey(key) {
+  if (!key) return '';
+  const trimmed = String(key).trim();
+  if (trimmed.length <= 6) return '****';
+  return `****${trimmed.slice(-4)}`;
+}
+/** Convert a millisecond duration into a compact human label. */
+export function humanizeDuration(ms) {
+  if (typeof ms !== 'number' || !Number.isFinite(ms) || ms <= 0) return 'now';
+  const sec = Math.floor(ms / 1000);
+  const min = Math.floor(sec / 60);
+  const hr = Math.floor(min / 60);
+  const day = Math.floor(hr / 24);
+  if (day >= 1) return `${day}d ${hr % 24}h`;
+  if (hr >= 1) return `${hr}h ${min % 60}m`;
+  if (min >= 1) return `${min}m`;
+  return `${sec}s`;
+}
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(hi, n));
+}

package/bizar-dash/src/server/routes/_shared.mjs CHANGED Viewed

@@ -134,6 +134,20 @@ export const DEFAULT_SETTINGS = {
     provider: 'opencode',
     model: 'opencode/deepseek-v4-flash-free',
   },
+  // v4.5.0 — MiniMax Token Plan integration. `apiKey` is the
+  // user's Subscription Key from
+  //   https://platform.minimax.io/user-center/payment/token-plan
+  // `groupId` is usually 'default' for an individual team. `baseUrl`
+  // is the Token Plan host (the remains endpoint lives on www.*, NOT
+  // api.*). `chatBaseUrl` is the chat-completions host (api.*).
+  // No key is shipped by default — the user enters their own.
+  minimax: {
+    enabled: true,
+    apiKey: '',
+    groupId: 'default',
+    baseUrl: 'https://www.minimax.io',
+    chatBaseUrl: 'https://api.minimax.io/v1',
+  },
 };
 /**
@@ -159,6 +173,7 @@ export function mergeSettings(existing) {
   merged.about = { ...DEFAULT_SETTINGS.about, ...(existing.about || {}) };
   merged.agents = { ...DEFAULT_SETTINGS.agents, ...(existing.agents || {}) };
   merged.systemLlm = { ...DEFAULT_SETTINGS.systemLlm, ...(existing.systemLlm || {}) };
+  merged.minimax = { ...DEFAULT_SETTINGS.minimax, ...(existing.minimax || {}) };
   // Always use the package version — never let user settings override it
   merged.about.version = DEFAULT_SETTINGS.about.version;
   return merged;

package/bizar-dash/src/server/routes/minimax.mjs ADDED Viewed

@@ -0,0 +1,140 @@
+/**
+ * src/server/routes/minimax.mjs
+ *
+ * v4.5.0 — REST surface for the MiniMax Token Plan integration.
+ *
+ * Endpoints:
+ *   GET  /api/minimax/status         — current key + cached remains summary
+ *   GET  /api/minimax/remains        — full remains snapshot (5h + weekly per model)
+ *   POST /api/minimax/remains/refresh — force re-fetch from the API
+ *   POST /api/minimax/test           — smoke-test the key with a one-shot chat call
+ *   GET  /api/minimax/cache          — read the on-disk cache file (for debugging)
+ *
+ * All endpoints read the API key from settings.json (no key is ever
+ * accepted as a URL param or body field — the user puts it in the
+ * settings UI). Responses never echo the key back; they include a
+ * masked `apiKeyHint` (last 4 chars only).
+ */
+import { Router } from 'express';
+import {
+  fetchRemains,
+  chatCompletion,
+  readCachedRemains,
+  clearRemainsCache,
+  readMinimaxSettings,
+  maskKey,
+  KNOWN_MODELS,
+} from '../minimax.mjs';
+import { wrap } from './_shared.mjs';
+/**
+ * @param {object} deps
+ * @param {object} deps.state
+ * @param {Function} deps.broadcast
+ * @returns {import('express').Router}
+ */
+export function createMinimaxRouter({ state, broadcast }) {
+  const router = Router();
+  // GET / — health + config summary
+  router.get('/minimax/status', wrap(async (_req, res) => {
+    const settings = readMinimaxSettings();
+    const cached = readCachedRemains();
+    res.json({
+      enabled: settings.enabled,
+      configured: !!settings.apiKey,
+      apiKeyHint: maskKey(settings.apiKey),
+      groupId: settings.groupId,
+      baseUrl: settings.baseUrl,
+      chatBaseUrl: settings.chatBaseUrl,
+      knownModels: KNOWN_MODELS,
+      cache: cached
+        ? {
+            fetchedAt: cached.fetchedAt,
+            apiKeyHint: cached.apiKeyHint,
+            groupId: cached.groupId,
+            modelCount: (cached.models || []).length,
+          }
+        : null,
+    });
+  }));
+  // GET /remains — current snapshot (cache-or-fetch)
+  router.get('/minimax/remains', wrap(async (_req, res) => {
+    const settings = readMinimaxSettings();
+    if (!settings.enabled) {
+      res.json({ ok: false, error: 'disabled', message: 'MiniMax integration is disabled in settings' });
+      return;
+    }
+    const result = await fetchRemains({
+      apiKey: settings.apiKey,
+      groupId: settings.groupId,
+      baseUrl: settings.baseUrl,
+    });
+    if (broadcast && result.ok) {
+      broadcast({ type: 'minimax:remains', remains: result });
+    }
+    res.json(result);
+  }));
+  // POST /remains/refresh — force re-fetch (bypass cache TTL)
+  router.post('/minimax/remains/refresh', wrap(async (_req, res) => {
+    const settings = readMinimaxSettings();
+    if (!settings.enabled) {
+      res.json({ ok: false, error: 'disabled', message: 'MiniMax integration is disabled in settings' });
+      return;
+    }
+    const result = await fetchRemains({
+      apiKey: settings.apiKey,
+      groupId: settings.groupId,
+      baseUrl: settings.baseUrl,
+      force: true,
+    });
+    if (broadcast && result.ok) {
+      broadcast({ type: 'minimax:remains:refreshed', remains: result });
+    }
+    res.json(result);
+  }));
+  // POST /test — smoke-test the key with a chat completion
+  router.post('/minimax/test', wrap(async (req, res) => {
+    const settings = readMinimaxSettings();
+    if (!settings.enabled) {
+      res.json({ ok: false, error: 'disabled', message: 'MiniMax integration is disabled in settings' });
+      return;
+    }
+    if (!settings.apiKey) {
+      res.json({ ok: false, error: 'no_api_key', message: 'MiniMax API key is not configured' });
+      return;
+    }
+    const body = req.body || {};
+    const prompt = typeof body.prompt === 'string' && body.prompt.trim()
+      ? body.prompt
+      : 'Reply with the single word: ok';
+    const model = typeof body.model === 'string' && body.model.trim()
+      ? body.model.trim()
+      : 'MiniMax-M3';
+    const result = await chatCompletion({
+      apiKey: settings.apiKey,
+      prompt,
+      model,
+      baseUrl: settings.chatBaseUrl,
+      maxTokens: typeof body.maxTokens === 'number' ? body.maxTokens : 32,
+    });
+    res.json(result);
+  }));
+  // GET /cache — read the on-disk cache (debugging)
+  router.get('/minimax/cache', wrap(async (_req, res) => {
+    res.json(readCachedRemains() || null);
+  }));
+  // DELETE /cache — clear cache (admin endpoint)
+  router.delete('/minimax/cache', wrap(async (_req, res) => {
+    clearRemainsCache();
+    if (broadcast) broadcast({ type: 'minimax:cache:cleared' });
+    res.json({ ok: true });
+  }));
+  return router;
+}

package/bizar-dash/src/web/App.tsx CHANGED Viewed

@@ -35,6 +35,7 @@ import { ModView, type ModView as ModViewType } from './views/ModView';
 import { Schedules } from './views/Schedules';
 import { Skills } from './views/Skills';
 import { History } from './views/History';
+import { MiniMaxUsage } from './views/MiniMaxUsage';
 import { BackgroundAgents } from './views/BackgroundAgents';
 import { Spinner } from './components/Spinner';
 import { Button } from './components/Button';
@@ -75,6 +76,7 @@ const VIEW_MAP: Record<string, (p: ViewProps) => React.ReactNode> = {
   schedules: Schedules,
   skills: Skills,
   history: History,
+  minimax: MiniMaxUsage,
 };
 const VERSION = 'v3.21.0';

package/bizar-dash/src/web/components/Topbar.tsx CHANGED Viewed

@@ -21,6 +21,7 @@ import {
   Sparkles,
   Activity,
   Radio,
+  Coins,
   type LucideIcon,
 } from 'lucide-react';
 import { cn } from '../lib/utils';
@@ -48,6 +49,7 @@ export const TABS: TabDef[] = [
   { id: 'mods', label: 'Mods', icon: Puzzle },
   { id: 'schedules', label: 'Schedules', icon: Clock },
   { id: 'history', label: 'History', icon: HistoryIcon },
+  { id: 'minimax', label: 'Usage', icon: Coins },
   { id: 'config', label: 'Config', icon: Settings2 },
   { id: 'settings', label: 'Settings', icon: Sliders },
 ];

package/bizar-dash/src/web/lib/types.ts CHANGED Viewed

@@ -265,6 +265,18 @@ export type Settings = {
   };
   // v3.21.0 — System LLM calls (auto-title, enhance-prompt, summarization).
   systemLlm?: SystemLlmConfig;
+  // v4.5.0 — MiniMax Token Plan integration. `apiKey` is the user's
+  // Subscription Key (NOT a pay-as-you-go API key). `groupId` is usually
+  // 'default' for an individual team. `baseUrl` is the Token Plan host
+  // (the remains endpoint lives on www.*, not api.*). `chatBaseUrl` is
+  // the chat-completions host (api.*/v1).
+  minimax?: {
+    enabled: boolean;
+    apiKey: string;
+    groupId: string;
+    baseUrl: string;
+    chatBaseUrl: string;
+  };
 };
 export type SettingsResponse = {

package/bizar-dash/src/web/main.tsx CHANGED Viewed

@@ -8,6 +8,7 @@ import { MobileApp } from './MobileApp';
 import './styles/main.css';
 import './styles/mobile.css';
 import './styles/glyphs.css';
+import './styles/minimax-usage.css';
 function Root() {
   const [isMobile, setIsMobile] = useState(() => {