termsearch 0.3.0 → 0.3.2

package/frontend/dist/style.css

@@ -159,6 +159,97 @@ a:hover { color: var(--link-h); }
   background: rgba(109,40,217,0.15);
 }
 
+.engine-picker {
+  margin-left: auto;
+  position: relative;
+}
+.engine-picker summary {
+  list-style: none;
+}
+.engine-picker summary::-webkit-details-marker {
+  display: none;
+}
+.engine-picker-summary {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 5px 10px;
+  border-radius: 999px;
+  border: 1px solid var(--border);
+  background: var(--bg2);
+  color: var(--text2);
+  font-size: 11px;
+  cursor: pointer;
+}
+.engine-picker-title {
+  white-space: nowrap;
+}
+.engine-chevron {
+  opacity: 0.8;
+}
+.engine-picker[open] .engine-chevron {
+  transform: rotate(180deg);
+}
+.engine-picker-body {
+  position: absolute;
+  right: 0;
+  top: calc(100% + 8px);
+  width: min(92vw, 560px);
+  max-height: min(65vh, 560px);
+  overflow: auto;
+  background: var(--bg2);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 10px;
+  z-index: 120;
+  box-shadow: 0 16px 32px rgba(0,0,0,0.4);
+}
+.engine-preset-row {
+  display: flex;
+  gap: 6px;
+  margin-bottom: 8px;
+  flex-wrap: wrap;
+}
+.engine-group {
+  padding: 8px;
+  border: 1px solid var(--border2);
+  border-radius: var(--radius-sm);
+  margin-bottom: 8px;
+}
+.engine-group-title {
+  font-size: 10px;
+  color: var(--text3);
+  margin-bottom: 7px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+.engine-chip-wrap {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.engine-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  padding: 4px 8px;
+  cursor: pointer;
+  font-size: 10px;
+  color: var(--text2);
+  background: #0d0d0d;
+}
+.engine-chip input {
+  margin: 0;
+}
+.engine-actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+  margin-top: 8px;
+}
+
 /* ─── Homepage ────────────────────────────────────────────────────────────── */
 .home {
   flex: 1;
@@ -192,7 +283,10 @@ a:hover { color: var(--link-h); }
   letter-spacing: 0.15em;
   text-transform: uppercase;
   margin-bottom: 32px;
+  text-align: center;
 }
+.tagline-mobile { display: none; }
+.tagline-desktop { display: inline; }
 
 .home-search { width: 100%; max-width: 560px; margin-bottom: 14px; }
 
@@ -458,8 +552,9 @@ a:hover { color: var(--link-h); }
 
 /* AI panel */
 .panel-ai {
-  background: var(--ai-bg);
+  background: linear-gradient(180deg, rgba(79,70,229,0.12) 0%, rgba(15,15,26,0.95) 42%);
   border: 1px solid var(--ai-border);
+  box-shadow: 0 12px 28px rgba(30,27,75,0.25);
 }
 .panel-ai .panel-header-label { color: var(--ai-text2); }
 .panel-ai .panel-label { color: var(--ai-text); font-size: 12px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.06em; }
@@ -476,6 +571,12 @@ a:hover { color: var(--link-h); }
   line-height: 1.7;
   white-space: pre-wrap;
   margin-top: 10px;
+  background: rgba(10,10,16,0.6);
+  border: 1px solid rgba(129,140,248,0.22);
+  border-radius: var(--radius-sm);
+  padding: 10px;
+  max-height: 280px;
+  overflow: auto;
 }
 .ai-meta { font-size: 11px; color: var(--text3); margin-top: 8px; }
 
@@ -655,6 +756,29 @@ a:hover { color: var(--link-h); }
 .form-input::placeholder { color: var(--text3); }
 .form-input[type="password"] { font-family: var(--font-mono); }
 .form-hint { font-size: 11px; color: var(--text3); margin-top: 3px; }
+.model-quick-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin-top: 8px;
+  max-height: 160px;
+  overflow: auto;
+  padding: 2px 1px 2px 0;
+}
+.model-chip-btn {
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  padding: 4px 8px;
+  background: #0b0b0b;
+  color: var(--text2);
+  font-size: 11px;
+  cursor: pointer;
+}
+.model-chip-btn.active {
+  color: var(--ai-text2);
+  border-color: rgba(109,40,217,0.5);
+  background: rgba(109,40,217,0.18);
+}
 
 .form-row {
   display: flex; gap: 8px; align-items: flex-end;
@@ -744,10 +868,16 @@ a:hover { color: var(--link-h); }
 /* ─── Responsive ──────────────────────────────────────────────────────────── */
 @media (max-width: 640px) {
   .header { padding: 8px 12px; gap: 8px; }
-  .category-tabs { top: 48px; padding: 7px 12px 9px; gap: 5px; }
+  .category-tabs { top: 48px; padding: 7px 12px 9px; gap: 5px; flex-wrap: wrap; }
   .cat-tab { font-size: 10px; padding: 4px 8px; }
+  .engine-picker { width: 100%; margin-left: 0; }
+  .engine-picker-summary { width: 100%; justify-content: space-between; }
+  .engine-picker-body { width: calc(100vw - 24px); right: -6px; }
   .logo-text { font-size: 15px; }
   .home-logo { font-size: 40px; }
+  .home-tagline { letter-spacing: 0.08em; margin-bottom: 20px; }
+  .tagline-desktop { display: none; }
+  .tagline-mobile { display: inline; }
   .result-title { font-size: 15px; }
   .settings-section { padding: 14px; }
   .form-row { flex-direction: column; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termsearch",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Personal search engine for Termux/Linux/macOS — zero-config, privacy-first, AI-optional",
   "type": "module",
   "bin": {

package/src/ai/providers/openai-compat.js

@@ -56,6 +56,151 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function isAnthropicBase(base) {
+  return /anthropic\.com/i.test(base);
+}
+
+function normalizeAnthropicBase(base) {
+  const clean = String(base || '').replace(/\/$/, '');
+  return /\/v1$/i.test(clean) ? clean : `${clean}/v1`;
+}
+
+function buildAnthropicHeaders(apiKey) {
+  return {
+    'Content-Type': 'application/json',
+    'anthropic-version': '2023-06-01',
+    ...(apiKey ? { 'x-api-key': apiKey } : {}),
+  };
+}
+
+function extractAnthropicText(payload) {
+  const parts = Array.isArray(payload?.content) ? payload.content : [];
+  return parts
+    .map((part) => (part?.type === 'text' ? String(part?.text || '') : ''))
+    .join('')
+    .trim();
+}
+
+async function callAnthropic(prompt, {
+  apiBase,
+  apiKey,
+  model,
+  maxTokens = 1200,
+  timeoutMs = 90_000,
+  systemPrompt = null,
+  temperature = 0.3,
+} = {}) {
+  if (!apiKey) throw buildAiError('ai_provider_auth', 'ai 401: authentication failed');
+  const base = normalizeAnthropicBase(apiBase);
+  const body = {
+    model,
+    max_tokens: maxTokens,
+    temperature,
+    messages: [{ role: 'user', content: prompt }],
+  };
+  if (systemPrompt) body.system = systemPrompt;
+
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${base}/messages`, {
+      method: 'POST',
+      headers: buildAnthropicHeaders(apiKey),
+      body: JSON.stringify(body),
+      signal: ac.signal,
+    });
+    if (response.status === 401 || response.status === 403) {
+      throw buildAiError('ai_provider_auth', `ai ${response.status}: authentication failed`);
+    }
+    if (response.status === 429) {
+      throw buildAiError('ai_rate_limited_provider', 'ai 429: rate limit exceeded');
+    }
+    if (!response.ok) {
+      const errBody = await response.text().catch(() => '');
+      throw new Error(`ai ${response.status}: ${errBody.slice(0, 220)}`);
+    }
+    const data = await response.json();
+    return {
+      content: extractAnthropicText(data),
+      reasoning: '',
+      model: data?.model || model,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function streamAnthropic(prompt, onToken, {
+  apiBase,
+  apiKey,
+  model,
+  maxTokens = 1200,
+  timeoutMs = 90_000,
+  systemPrompt = null,
+  temperature = 0.3,
+} = {}) {
+  if (!apiKey) throw buildAiError('ai_provider_auth', 'ai 401: authentication failed');
+  const base = normalizeAnthropicBase(apiBase);
+  const body = {
+    model,
+    max_tokens: maxTokens,
+    temperature,
+    stream: true,
+    messages: [{ role: 'user', content: prompt }],
+  };
+  if (systemPrompt) body.system = systemPrompt;
+
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${base}/messages`, {
+      method: 'POST',
+      headers: buildAnthropicHeaders(apiKey),
+      body: JSON.stringify(body),
+      signal: ac.signal,
+    });
+    if (response.status === 401 || response.status === 403) {
+      throw buildAiError('ai_provider_auth', `ai ${response.status}: authentication failed`);
+    }
+    if (response.status === 429) {
+      throw buildAiError('ai_rate_limited_provider', 'ai 429: rate limit exceeded');
+    }
+    if (!response.ok) {
+      const errBody = await response.text().catch(() => '');
+      throw new Error(`ai ${response.status}: ${errBody.slice(0, 220)}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let fullContent = '';
+    let buffer = '';
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const raw = line.slice(6).trim();
+        if (!raw || raw === '[DONE]') continue;
+        try {
+          const parsed = JSON.parse(raw);
+          const chunk = parsed?.delta?.text || parsed?.text || '';
+          if (!chunk) continue;
+          fullContent += chunk;
+          onToken(chunk, fullContent);
+        } catch {
+          // ignore malformed SSE chunk
+        }
+      }
+    }
+    return { content: fullContent.trim(), reasoning: '', model };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // Single non-streaming call with retry logic
 // Returns { content, reasoning, model } or throws
 export async function call(prompt, {
@@ -70,6 +215,9 @@ export async function call(prompt, {
 } = {}) {
   const base = String(apiBase || '').replace(/\/$/, '');
   if (!base || !model) throw buildAiError('ai_unavailable', 'AI not configured');
+  if (isAnthropicBase(base)) {
+    return callAnthropic(prompt, { apiBase: base, apiKey, model, maxTokens, timeoutMs, systemPrompt, temperature });
+  }
 
   const messages = systemPrompt
     ? [{ role: 'system', content: systemPrompt }, { role: 'user', content: prompt }]
@@ -155,6 +303,9 @@ export async function stream(prompt, onToken, {
 } = {}) {
   const base = String(apiBase || '').replace(/\/$/, '');
   if (!base || !model) throw buildAiError('ai_unavailable', 'AI not configured');
+  if (isAnthropicBase(base)) {
+    return streamAnthropic(prompt, onToken, { apiBase: base, apiKey, model, maxTokens, timeoutMs, systemPrompt, temperature });
+  }
 
   const messages = systemPrompt
     ? [{ role: 'system', content: systemPrompt }, { role: 'user', content: prompt }]

package/src/api/routes.js

@@ -1,7 +1,7 @@
 // All API route handlers
 
 import express from 'express';
-import { search, searchStream, getEnabledProviders, getDocCache } from '../search/engine.js';
+import { search, searchStream, getEnabledProviders, getDocCache, ALLOWED_ENGINES } from '../search/engine.js';
 import { batchFetch, fetchReadableDocument } from '../fetch/document.js';
 import { generateSummary, testConnection } from '../ai/orchestrator.js';
 import { refineQuery } from '../ai/query.js';
@@ -11,8 +11,9 @@ import { detectProfileTarget, scanProfile, PROFILER_PLATFORMS } from '../profile
 import { fetchBlueskyPosts, fetchBlueskyActors, fetchGdeltArticles } from '../social/search.js';
 import { scrapeTPB, scrape1337x, extractMagnetFromUrl } from '../torrent/scrapers.js';
 
-const APP_VERSION = '0.3.0';
+const APP_VERSION = '0.3.2';
 const ALLOWED_CATEGORIES = new Set(['web', 'images', 'news']);
+const ALLOWED_LANGS = new Set(['auto', 'it-IT', 'en-US', 'es-ES', 'fr-FR', 'de-DE', 'pt-PT', 'ru-RU', 'zh-CN', 'ja-JP']);
 
 function parseCategory(raw) {
   const category = String(raw || 'web').trim().toLowerCase();
@@ -22,13 +23,184 @@ function parseCategory(raw) {
 function parseEngines(raw) {
   if (!raw) return [];
   const source = Array.isArray(raw) ? raw.join(',') : String(raw);
-  return [...new Set(
+  const parsed = [...new Set(
     source
       .split(',')
       .map((entry) => entry.trim().toLowerCase())
       .filter(Boolean)
       .slice(0, 12)
   )];
+  if (!parsed.every((engine) => ALLOWED_ENGINES.has(engine))) return null;
+  return parsed;
+}
+
+function normalizeLang(raw) {
+  const input = String(raw || '').trim();
+  if (!input) return null;
+  const lower = input.toLowerCase();
+  const exact = [...ALLOWED_LANGS].find((lang) => lang.toLowerCase() === lower);
+  if (exact) return exact;
+  const shortMap = {
+    it: 'it-IT',
+    en: 'en-US',
+    es: 'es-ES',
+    fr: 'fr-FR',
+    de: 'de-DE',
+    pt: 'pt-PT',
+    ru: 'ru-RU',
+    zh: 'zh-CN',
+    ja: 'ja-JP',
+  };
+  return shortMap[lower] || null;
+}
+
+function resolveLang(rawLang, acceptLanguageHeader = '') {
+  const normalized = normalizeLang(rawLang || 'auto');
+  if (normalized && normalized !== 'auto') return normalized;
+  const first = String(acceptLanguageHeader || '')
+    .split(',')
+    .map((part) => part.trim().split(';')[0])
+    .find(Boolean);
+  const fromHeader = normalizeLang(first || '');
+  return fromHeader || 'en-US';
+}
+
+function normalizeBase(rawBase) {
+  const raw = String(rawBase || '').trim();
+  if (!raw) return '';
+  return raw.replace(/\/$/, '');
+}
+
+function detectModelProvider(base, preset = '') {
+  const p = String(preset || '').trim().toLowerCase();
+  if (p === 'openroute') return 'openrouter';
+  if (p && p !== 'custom') return p;
+  const b = String(base || '').toLowerCase();
+  if (b.includes('anthropic.com')) return 'anthropic';
+  if (b.includes('openrouter.ai')) return 'openrouter';
+  if (b.includes('openai.com')) return 'openai';
+  if (b.includes('chutes.ai')) return 'chutes';
+  if (b.includes(':11434')) return 'ollama';
+  if (b.includes(':1234')) return 'lmstudio';
+  if (b.includes(':8080')) return 'llamacpp';
+  return 'openai_compat';
+}
+
+function parseModelPayload(payload) {
+  if (Array.isArray(payload)) {
+    return payload.map((item) => typeof item === 'string' ? item.trim() : String(item?.id || item?.name || '').trim()).filter(Boolean);
+  }
+  if (!payload || typeof payload !== 'object') return [];
+  if (Array.isArray(payload.data)) {
+    return payload.data.map((item) => String(item?.id || '').trim()).filter(Boolean);
+  }
+  if (Array.isArray(payload.models)) {
+    return payload.models.map((item) => typeof item === 'string' ? item.trim() : String(item?.id || item?.name || '').trim()).filter(Boolean);
+  }
+  if (Array.isArray(payload?.result?.models)) {
+    return payload.result.models.map((item) => typeof item === 'string' ? item.trim() : String(item?.id || item?.name || '').trim()).filter(Boolean);
+  }
+  return [];
+}
+
+function buildModelAuthVariants(provider, apiKey) {
+  const key = String(apiKey || '').trim();
+  if (!key) return [{ Accept: 'application/json' }];
+  if (provider === 'chutes') {
+    return [
+      { Accept: 'application/json', Authorization: `Bearer ${key}` },
+      { Accept: 'application/json', 'x-api-key': key },
+      { Accept: 'application/json', Authorization: `Bearer ${key}`, 'x-api-key': key },
+    ];
+  }
+  return [{ Accept: 'application/json', Authorization: `Bearer ${key}` }];
+}
+
+async function fetchOpenAiCompatibleModels(base, apiKey, provider = 'openai_compat', timeoutMs = 10000) {
+  const variants = buildModelAuthVariants(provider, apiKey);
+  for (const headers of variants) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${base}/models`, { headers, signal: ac.signal });
+      if (!response.ok) continue;
+      const payload = await response.json();
+      const parsed = parseModelPayload(payload);
+      if (parsed.length > 0) return parsed;
+    } catch {
+      // try next variant
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  return [];
+}
+
+async function fetchOpenRouterModels(base, apiKey, timeoutMs = 10000) {
+  const endpoint = base.includes('/api/v1') ? `${base}/models` : `${base}/api/v1/models`;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const headers = { Accept: 'application/json' };
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+    const response = await fetch(endpoint, { headers, signal: ac.signal });
+    if (!response.ok) return [];
+    const payload = await response.json();
+    return parseModelPayload(payload);
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function fetchAnthropicModels(base, apiKey, timeoutMs = 10000) {
+  if (!apiKey) return [];
+  const endpoint = base.endsWith('/v1') ? `${base}/models` : `${base}/v1/models`;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const response = await fetch(endpoint, {
+      headers: {
+        Accept: 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      signal: ac.signal,
+    });
+    if (!response.ok) return [];
+    const payload = await response.json();
+    return parseModelPayload(payload);
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function fetchOllamaModels(base, timeoutMs = 10000) {
+  const origin = (() => {
+    try {
+      const u = new URL(base);
+      return `${u.protocol}//${u.host}`;
+    } catch {
+      return base;
+    }
+  })();
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${origin}/api/tags`, { headers: { Accept: 'application/json' }, signal: ac.signal });
+    if (!response.ok) return [];
+    const payload = await response.json();
+    return (payload?.models || [])
+      .map((item) => String(item?.name || '').trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
 }
 
 export function createRouter(config, rateLimiters) {
@@ -68,6 +240,7 @@ export function createRouter(config, rateLimiters) {
         '/api/magnet': { post: { summary: 'Extract magnet from page URL' } },
         '/api/scan': { post: { summary: 'Scan site pages by query' } },
         '/api/config': { get: { summary: 'Read config (masked)' }, post: { summary: 'Update config' } },
+        '/api/config/models': { post: { summary: 'List AI models from selected provider endpoint' } },
       },
     });
   });
@@ -84,11 +257,12 @@ export function createRouter(config, rateLimiters) {
     if (!q) return sendJson(res, 400, { error: 'missing_query', message: 'q parameter required' });
     if (q.length > cfg.search.max_query_length) return sendJson(res, 400, { error: 'query_too_long' });
 
-    const lang = String(req.query.lang || 'en-US');
+    const lang = resolveLang(req.query.lang, req.headers['accept-language']);
     const safe = String(req.query.safe || '1');
     const page = Number(req.query.page || '1');
     const category = parseCategory(req.query.cat);
     const engines = parseEngines(req.query.engines);
+    if (engines === null) return sendJson(res, 400, { error: 'invalid_engines', message: 'engines must be a comma-separated allowlisted set.' });
 
     try {
       const result = await search({ query: q, lang, safe, page, category, engines }, cfg);
@@ -111,11 +285,12 @@ export function createRouter(config, rateLimiters) {
     if (!q) return sendJson(res, 400, { error: 'missing_query' });
     if (q.length > cfg.search.max_query_length) return sendJson(res, 400, { error: 'query_too_long' });
 
-    const lang = String(req.query.lang || 'en-US');
+    const lang = resolveLang(req.query.lang, req.headers['accept-language']);
     const safe = String(req.query.safe || '1');
     const page = Number(req.query.page || '1');
     const category = parseCategory(req.query.cat);
     const engines = parseEngines(req.query.engines);
+    if (engines === null) return sendJson(res, 400, { error: 'invalid_engines', message: 'engines must be a comma-separated allowlisted set.' });
 
     applySecurityHeaders(res);
     res.setHeader('Content-Type', 'text/event-stream');
@@ -134,6 +309,8 @@ export function createRouter(config, rateLimiters) {
             lang,
             results: chunk.results || [],
             providers: chunk.providers || [],
+            degraded: chunk.degraded === true,
+            engineStats: chunk.engineStats || { responded: chunk.providers || [], failed: [], unstable: [], health: {} },
           });
         } else {
           send({
@@ -143,8 +320,8 @@ export function createRouter(config, rateLimiters) {
             results: chunk.results || [],
             allResults: chunk.results || [],
             providers: chunk.providers || [],
-            degraded: false,
-            engineStats: { responded: chunk.providers || [], failed: [], unstable: [], health: {} },
+            degraded: chunk.degraded === true,
+            engineStats: chunk.engineStats || { responded: chunk.providers || [], failed: [], unstable: [], health: {} },
           });
         }
       }
@@ -189,7 +366,7 @@ export function createRouter(config, rateLimiters) {
     if (!cfg.ai?.enabled) return sendJson(res, 200, { refined_query: req.body?.query, intent: 'other', also_search: [] });
 
     const query = String(req.body?.query || '').trim();
-    const lang = String(req.body?.lang || 'en-US');
+    const lang = resolveLang(req.body?.lang, req.headers['accept-language']);
     if (!query) return sendJson(res, 400, { error: 'missing_query' });
 
     const result = await refineQuery({ query, lang }, cfg.ai);
@@ -213,7 +390,7 @@ export function createRouter(config, rateLimiters) {
     }
 
     const query = String(req.body?.query || '').trim();
-    const lang = String(req.body?.lang || 'en-US');
+    const lang = resolveLang(req.body?.lang, req.headers['accept-language']);
     const results = Array.isArray(req.body?.results) ? req.body.results : [];
     const session = Array.isArray(req.body?.session) ? req.body.session.slice(-4) : [];
     const streamMode = req.body?.stream !== false;
@@ -305,6 +482,38 @@ export function createRouter(config, rateLimiters) {
     sendJson(res, 405, { error: 'method_not_allowed', message: 'Use POST /api/config/test-ai' });
   });
 
+  // ─── Fetch provider model list ───────────────────────────────────────────
+  router.post('/api/config/models', express.json({ limit: '8kb' }), async (req, res) => {
+    const ip = req.clientIp;
+    if (!rateLimiters.checkGeneral(ip)) {
+      return sendRateLimited(res, { windowMs: rateLimiters.windowMs });
+    }
+    const cfg = config.getConfig();
+    const base = normalizeBase(req.body?.api_base || cfg.ai?.api_base || '');
+    const apiKey = String(req.body?.api_key || cfg.ai?.api_key || '');
+    const preset = String(req.body?.preset || '').trim().toLowerCase();
+    if (!base) return sendJson(res, 400, { ok: false, error: 'missing_api_base' });
+
+    const provider = detectModelProvider(base, preset);
+    let models = [];
+    if (provider === 'anthropic') {
+      models = await fetchAnthropicModels(base, apiKey);
+    } else if (provider === 'openrouter') {
+      models = await fetchOpenRouterModels(base, apiKey);
+    } else if (provider === 'ollama') {
+      models = await fetchOllamaModels(base);
+      if (models.length === 0) {
+        models = await fetchOpenAiCompatibleModels(base, apiKey, provider);
+      }
+    } else {
+      models = await fetchOpenAiCompatibleModels(base, apiKey, provider);
+    }
+
+    models = [...new Set(models)].slice(0, 80);
+    applySecurityHeaders(res);
+    res.json({ ok: true, provider, models });
+  });
+
   // ─── Test search provider ─────────────────────────────────────────────────
   router.get('/api/config/test-provider/:name', async (req, res) => {
     const cfg = config.getConfig();
@@ -327,7 +536,11 @@ export function createRouter(config, rateLimiters) {
         results = await mojeekSearch({ query: testQuery, config: cfg, timeoutMs: 8000 });
       } else if (name === 'searxng') {
         const { search: searxSearch } = await import('../search/providers/searxng.js');
-        results = await searxSearch({ query: testQuery, config: cfg, timeoutMs: 8000 });
+        const response = await searxSearch({ query: testQuery, config: cfg, timeoutMs: 8000 });
+        results = Array.isArray(response) ? response : (response?.results || []);
+      } else if (name === 'github') {
+        const { search: githubSearch } = await import('../search/providers/github.js');
+        results = await githubSearch({ query: testQuery, config: cfg, timeoutMs: 8000 });
       } else {
         return sendJson(res, 400, { error: 'unknown_provider' });
       }