muxmind-ai 2.1.1

package/src/config.js

@@ -0,0 +1,267 @@
+/**
+ * MuxMind AI — System Configuration
+ * Provider catalog, model fallback chains, and system-wide constants.
+ * NOTE: No API keys live here. Keys are supplied per-request by the client
+ * from its own local vault (localStorage) or from a local .env the user
+ * controls on their own machine. This file is safe to publish publicly.
+ */
+
+'use strict';
+
+const PROVIDERS = {
+  openai: {
+    id: 'openai',
+    label: 'OpenAI',
+    color: '#10a37f',
+    baseUrl: 'https://api.openai.com/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['gpt-4o-mini', 'gpt-4o', 'gpt-4.1-mini', 'gpt-4.1', 'o4-mini'],
+    keyConsoleUrl: 'https://platform.openai.com/api-keys',
+    docsUrl: 'https://platform.openai.com/docs/api-reference',
+    keyPrefix: 'sk-',
+  },
+  anthropic: {
+    id: 'anthropic',
+    label: 'Anthropic',
+    color: '#d97757',
+    baseUrl: 'https://api.anthropic.com/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/messages',
+    authHeader: (key) => ({ 'x-api-key': key, 'anthropic-version': '2023-06-01' }),
+    defaultModels: ['claude-sonnet-4-6', 'claude-haiku-4-5', 'claude-opus-4-1', 'claude-3-5-haiku-20241022'],
+    keyConsoleUrl: 'https://console.anthropic.com/settings/keys',
+    docsUrl: 'https://docs.claude.com',
+    keyPrefix: 'sk-ant-',
+  },
+  groq: {
+    id: 'groq',
+    label: 'Groq',
+    color: '#f55036',
+    baseUrl: 'https://api.groq.com/openai/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['llama-3.1-8b-instant', 'llama-3.3-70b-versatile'],
+    keyConsoleUrl: 'https://console.groq.com/keys',
+    docsUrl: 'https://console.groq.com/docs',
+    keyPrefix: 'gsk_',
+  },
+  gemini: {
+    id: 'gemini',
+    label: 'Google Gemini',
+    color: '#4285f4',
+    baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/models/{model}:generateContent',
+    authHeader: () => ({}),
+    authQuery: (key) => `key=${key}`,
+    defaultModels: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.0-flash', 'gemini-1.5-flash', 'gemini-1.5-pro'],
+    keyConsoleUrl: 'https://aistudio.google.com/app/apikey',
+    docsUrl: 'https://ai.google.dev/gemini-api/docs',
+    keyPrefix: 'AIza',
+  },
+  openrouter: {
+    id: 'openrouter',
+    label: 'OpenRouter',
+    color: '#8b5cf6',
+    baseUrl: 'https://openrouter.ai/api/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['meta-llama/llama-3.1-8b-instruct:free'],
+    keyConsoleUrl: 'https://openrouter.ai/settings/keys',
+    docsUrl: 'https://openrouter.ai/docs',
+    keyPrefix: 'sk-or-',
+  },
+  mistral: {
+    id: 'mistral',
+    label: 'Mistral AI',
+    color: '#fa520f',
+    baseUrl: 'https://api.mistral.ai/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['mistral-small-latest', 'mistral-large-latest'],
+    keyConsoleUrl: 'https://console.mistral.ai/api-keys',
+    docsUrl: 'https://docs.mistral.ai',
+    keyPrefix: '',
+  },
+  deepseek: {
+    id: 'deepseek',
+    label: 'DeepSeek',
+    color: '#4d6bfe',
+    baseUrl: 'https://api.deepseek.com/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['deepseek-chat', 'deepseek-reasoner'],
+    keyConsoleUrl: 'https://platform.deepseek.com/api_keys',
+    docsUrl: 'https://api-docs.deepseek.com',
+    keyPrefix: 'sk-',
+  },
+  xai: {
+    id: 'xai',
+    label: 'xAI (Grok)',
+    color: '#1a1a1a',
+    baseUrl: 'https://api.x.ai/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['grok-3-mini', 'grok-3'],
+    keyConsoleUrl: 'https://console.x.ai',
+    docsUrl: 'https://docs.x.ai',
+    keyPrefix: 'xai-',
+  },
+  cohere: {
+    id: 'cohere',
+    label: 'Cohere',
+    color: '#39594d',
+    baseUrl: 'https://api.cohere.com/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['command-r', 'command-r-plus'],
+    keyConsoleUrl: 'https://dashboard.cohere.com/api-keys',
+    docsUrl: 'https://docs.cohere.com',
+    keyPrefix: '',
+  },
+  together: {
+    id: 'together',
+    label: 'Together AI',
+    color: '#0f6fff',
+    baseUrl: 'https://api.together.xyz/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['meta-llama/Llama-3.3-70B-Instruct-Turbo-Free', 'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo'],
+    keyConsoleUrl: 'https://api.together.xyz/settings/api-keys',
+    docsUrl: 'https://docs.together.ai',
+    keyPrefix: '',
+  },
+  cerebras: {
+    id: 'cerebras',
+    label: 'Cerebras',
+    color: '#f6521f',
+    baseUrl: 'https://api.cerebras.ai/v1',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['llama3.1-8b', 'llama-3.3-70b'],
+    keyConsoleUrl: 'https://cloud.cerebras.ai',
+    docsUrl: 'https://inference-docs.cerebras.ai',
+    keyPrefix: 'csk-',
+  },
+  perplexity: {
+    id: 'perplexity',
+    label: 'Perplexity',
+    color: '#20808d',
+    baseUrl: 'https://api.perplexity.ai',
+    modelsEndpoint: '/models',
+    chatEndpoint: '/chat/completions',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    defaultModels: ['sonar', 'sonar-pro'],
+    keyConsoleUrl: 'https://www.perplexity.ai/settings/api',
+    docsUrl: 'https://docs.perplexity.ai',
+    keyPrefix: 'pplx-',
+  },
+};
+
+// Priority order for the staggered round-robin token optimizer.
+const FALLBACK_CHAIN = ['groq', 'cerebras', 'gemini', 'deepseek', 'mistral', 'together', 'xai', 'cohere', 'openai', 'anthropic', 'perplexity', 'openrouter'];
+
+// Providers with a documented image-generation endpoint we can drive from
+// the same vault key the user already validated for chat.
+const IMAGE_PROVIDERS = {
+  openai: {
+    endpoint: '/images/generations',
+    defaultModel: 'gpt-image-1',
+    buildBody: (prompt, opts) => ({ model: 'gpt-image-1', prompt, size: opts.size || '1024x1024', n: 1 }),
+    extractImages: (data) => (data.data || []).map((d) => (d.b64_json ? `data:image/png;base64,${d.b64_json}` : d.url)),
+  },
+  gemini: {
+    endpoint: '/models/{model}:generateContent',
+    // Google renames/retires its image-capable Gemini models fairly often
+    // (the old 'gemini-2.0-flash-exp-image-generation' preview is gone).
+    // Rather than pin one name that can go stale, we try this list in
+    // order and fall through to the next on a 404/"not found" style error.
+    defaultModel: 'gemini-3.1-flash-image',
+    fallbackModels: [
+      'gemini-3.1-flash-image',
+      'gemini-2.5-flash-image',
+      'gemini-2.5-flash-image-preview',
+      'gemini-2.0-flash-exp-image-generation',
+    ],
+    buildBody: (prompt) => ({
+      contents: [{ role: 'user', parts: [{ text: prompt }] }],
+      generationConfig: { responseModalities: ['TEXT', 'IMAGE'] },
+    }),
+    extractImages: (data) => {
+      const parts = data.candidates?.[0]?.content?.parts || [];
+      return parts
+        .filter((p) => p.inlineData)
+        .map((p) => `data:${p.inlineData.mimeType || 'image/png'};base64,${p.inlineData.data}`);
+    },
+  },
+};
+
+const COMPRESSION_LEVELS = {
+  0: { label: 'Off', maxTokensFactor: 1.0, chunkSize: 0 },
+  25: { label: 'Light', maxTokensFactor: 0.75, chunkSize: 96 },
+  50: { label: 'Balanced', maxTokensFactor: 0.5, chunkSize: 48 },
+  75: { label: 'Aggressive', maxTokensFactor: 0.25, chunkSize: 20 },
+  99: { label: 'Extreme (99%)', maxTokensFactor: 0.01, chunkSize: 6 },
+};
+
+const SERVER_CONFIG = {
+  PORT: process.env.PORT || 8080,
+  RATE_LIMIT_WINDOW_MS: 60 * 1000,
+  RATE_LIMIT_MAX: 120,
+  LOGIN_RATE_LIMIT_MAX: 8,
+  BODY_LIMIT: '25mb',
+  ALLOWED_UPLOAD_EXT: ['.js', '.html', '.css', '.py', '.pdf', '.txt', '.png', '.jpg', '.jpeg', '.json', '.md'],
+  MAX_UPLOAD_SIZE_BYTES: 15 * 1024 * 1024,
+  SESSION_TTL_MS: 12 * 60 * 60 * 1000,
+  // Global npm installs put this package under a system-owned
+  // node_modules dir (often not writable, and shared across all users).
+  // Persist the auth store per-OS-user instead: ~/.muxmind-ai/auth.json
+  // (or %USERPROFILE%\.muxmind-ai\auth.json on Windows). This also means
+  // your login password survives a `npm update -g`.
+  AUTH_STORE_PATH: (() => {
+    const path = require('path');
+    const os = require('os');
+    const fs = require('fs');
+    const dir = path.join(os.homedir(), '.muxmind-ai');
+    try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+    return path.join(dir, 'auth.json');
+  })(),
+};
+
+const TTS_CONFIG = {
+  languages: {
+    ar: { code: 'ar-SA', label: 'Arabic' },
+    en: { code: 'en-US', label: 'English' },
+  },
+  defaultRate: 1.0,
+  defaultPitch: 1.0,
+};
+
+// Model-name heuristics used by the smart router to estimate a model's
+// relative "power" and "speed" tiers when the provider doesn't expose this
+// directly. Used to pick a sensible model automatically per task.
+const MODEL_HINTS = [
+  { pattern: /mini|flash|8b|small|instant|haiku/i, tier: 'fast', power: 1 },
+  { pattern: /70b|large|pro(?!filic)|sonnet/i, tier: 'balanced', power: 2 },
+  { pattern: /opus|405b|reasoner|o1|o3|ultra/i, tier: 'heavy', power: 3 },
+];
+
+module.exports = {
+  PROVIDERS,
+  IMAGE_PROVIDERS,
+  FALLBACK_CHAIN,
+  COMPRESSION_LEVELS,
+  SERVER_CONFIG,
+  TTS_CONFIG,
+  MODEL_HINTS,
+};

package/src/file-parser.js

@@ -0,0 +1,122 @@
+/**
+ * MuxMind AI — Multi-Modal Upload Handler
+ * Parses uploaded files (code, text, PDF, images) into a normalized
+ * shape the router can inject into the conversation context.
+ */
+
+'use strict';
+
+const path = require('path');
+const { SERVER_CONFIG } = require('./config');
+
+const TEXT_EXTENSIONS = new Set(['.js', '.html', '.css', '.py', '.txt', '.json', '.md']);
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg']);
+const PDF_EXTENSIONS = new Set(['.pdf']);
+
+function validateUpload(filename, sizeBytes) {
+  const ext = path.extname(filename).toLowerCase();
+  if (!SERVER_CONFIG.ALLOWED_UPLOAD_EXT.includes(ext)) {
+    return { ok: false, error: `File type ${ext} is not allowed.` };
+  }
+  if (sizeBytes > SERVER_CONFIG.MAX_UPLOAD_SIZE_BYTES) {
+    return { ok: false, error: `File exceeds max size of ${SERVER_CONFIG.MAX_UPLOAD_SIZE_BYTES / (1024 * 1024)}MB.` };
+  }
+  return { ok: true, ext };
+}
+
+/**
+ * Normalize an uploaded file buffer into a context-ready payload.
+ * - text/code files: returned as plain text, fenced by filename
+ * - images: returned as base64 data URLs for vision-capable models
+ * - PDFs: returned as base64 for provider-native PDF ingestion (e.g. Anthropic)
+ */
+function parseUpload({ filename, mimetype, buffer }) {
+  const validation = validateUpload(filename, buffer.length);
+  if (!validation.ok) {
+    return { ok: false, error: validation.error, filename };
+  }
+
+  const ext = validation.ext;
+
+  if (TEXT_EXTENSIONS.has(ext)) {
+    return {
+      ok: true,
+      type: 'text',
+      filename,
+      ext,
+      content: buffer.toString('utf-8'),
+    };
+  }
+
+  if (IMAGE_EXTENSIONS.has(ext)) {
+    return {
+      ok: true,
+      type: 'image',
+      filename,
+      ext,
+      mimeType: mimetype || guessMime(ext),
+      base64: buffer.toString('base64'),
+    };
+  }
+
+  if (PDF_EXTENSIONS.has(ext)) {
+    return {
+      ok: true,
+      type: 'pdf',
+      filename,
+      ext,
+      mimeType: 'application/pdf',
+      base64: buffer.toString('base64'),
+    };
+  }
+
+  return { ok: false, error: `Unsupported file type: ${ext}`, filename };
+}
+
+function guessMime(ext) {
+  const map = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.pdf': 'application/pdf',
+    '.js': 'text/javascript',
+    '.css': 'text/css',
+    '.html': 'text/html',
+    '.py': 'text/x-python',
+    '.txt': 'text/plain',
+    '.json': 'application/json',
+    '.md': 'text/markdown',
+  };
+  return map[ext] || 'application/octet-stream';
+}
+
+/**
+ * Convert a batch of parsed uploads into a single text block that can be
+ * appended to the user's prompt as context (for text/code files), plus a
+ * separate array of image/pdf attachments for multi-modal providers.
+ */
+function buildContextFromUploads(parsedFiles) {
+  const textBlocks = [];
+  const attachments = [];
+
+  for (const file of parsedFiles) {
+    if (!file.ok) continue;
+    if (file.type === 'text') {
+      textBlocks.push(`--- FILE: ${file.filename} ---\n${file.content}\n--- END FILE ---`);
+    } else {
+      attachments.push(file);
+    }
+  }
+
+  return {
+    contextText: textBlocks.join('\n\n'),
+    attachments,
+  };
+}
+
+module.exports = {
+  validateUpload,
+  parseUpload,
+  buildContextFromUploads,
+  guessMime,
+};

package/src/image-engine.js

@@ -0,0 +1,73 @@
+/**
+ * MuxMind AI — Image Generation Engine
+ * Drives an image-generation request through whichever vault key the
+ * client marks capable (OpenAI or Gemini). Keys are used only for the
+ * duration of the single request, never persisted server-side, matching
+ * the same policy as the chat router and health-check.
+ */
+
+'use strict';
+
+const { PROVIDERS, IMAGE_PROVIDERS } = require('./config');
+
+// A model is "gone" (renamed/retired/never existed under that id) rather
+// than just erroring on this particular request — safe to silently retry
+// the next candidate in that case, but not for other failures (bad key,
+// quota, safety block, etc.) which should surface to the user immediately.
+function isModelUnavailable(httpStatus, errText) {
+  if (httpStatus === 404) return true;
+  const msg = (errText || '').toLowerCase();
+  return (
+    msg.includes('not found') ||
+    msg.includes('not supported') ||
+    msg.includes('is not available') ||
+    msg.includes('unknown model') ||
+    msg.includes('deprecated')
+  );
+}
+
+async function callOnce(provider, imageConf, apiKey, chosenModel, prompt, size) {
+  const body = imageConf.buildBody(prompt, { size });
+  let url = `${provider.baseUrl}${imageConf.endpoint.replace('{model}', chosenModel)}`;
+  const headers = { 'Content-Type': 'application/json', ...provider.authHeader(apiKey) };
+  if (provider.authQuery) url += `?${provider.authQuery(apiKey)}`;
+
+  const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body) });
+  if (!res.ok) {
+    const errText = await res.text().catch(() => res.statusText);
+    const err = new Error(`${provider.label} image error (HTTP ${res.status}): ${errText.slice(0, 300)}`);
+    err.httpStatus = res.status;
+    err.rawText = errText;
+    throw err;
+  }
+  const data = await res.json();
+  const images = imageConf.extractImages(data).filter(Boolean);
+  if (images.length === 0) throw new Error(`${provider.label} returned no image data.`);
+  return images;
+}
+
+async function generateImage({ providerId, apiKey, model, prompt, size }) {
+  const provider = PROVIDERS[providerId];
+  const imageConf = IMAGE_PROVIDERS[providerId];
+  if (!provider || !imageConf) throw new Error(`Provider ${providerId} does not support image generation.`);
+
+  // If the caller pinned a specific model, respect it — no fallback walk.
+  // Otherwise walk the known-good candidate list until one actually works.
+  const candidates = model ? [model] : (imageConf.fallbackModels && imageConf.fallbackModels.length
+    ? imageConf.fallbackModels
+    : [imageConf.defaultModel]);
+
+  let lastErr;
+  for (const candidateModel of candidates) {
+    try {
+      return await callOnce(provider, imageConf, apiKey, candidateModel, prompt, size);
+    } catch (err) {
+      lastErr = err;
+      if (!isModelUnavailable(err.httpStatus, err.rawText)) throw err; // real error — stop and surface it
+      // otherwise: this model id is gone, try the next candidate
+    }
+  }
+  throw lastErr || new Error(`${provider.label} has no working image model available right now.`);
+}
+
+module.exports = { generateImage };