termsearch 0.3.0 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # TermSearch - Personal Search Engine
 
-[![Status](https://img.shields.io/badge/Status-0.3.0-blue.svg)](#project-status)
+[![Status](https://img.shields.io/badge/Status-0.3.1-blue.svg)](#project-status)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/Node.js-18%2B-green.svg)](https://nodejs.org)
 [![Target](https://img.shields.io/badge/Target-Termux%20%2F%20Linux%20%2F%20macOS-green.svg)](https://termux.dev)
@@ -22,7 +22,7 @@ Core capabilities:
 
 ## Project Status
 
-- Current line: `0.3.0`
+- Current line: `0.3.1`
 - Core is MIT — zero required API keys
 - AI features are optional, configured via Settings page in browser
 - Tested on: Ubuntu 24.04, Termux (Android 15/16)

package/bin/termsearch.js

@@ -32,7 +32,7 @@ function info(msg) { console.log(`  ${CYAN}→${RESET} ${msg}`); }
 
 // ─── Package version ──────────────────────────────────────────────────────
 
-let VERSION = '0.3.0';
+let VERSION = '0.3.1';
 try { VERSION = JSON.parse(readFileSync(PKG_PATH, 'utf8')).version || VERSION; } catch { /* ignore */ }
 
 // ─── Data dir + paths ─────────────────────────────────────────────────────

package/frontend/dist/app.js

@@ -16,6 +16,15 @@ const state = {
   loading: false,
   providers: [],
   config: null,
+  historyEnabled: localStorage.getItem('ts-save-history') !== '0',
+  searchHistory: (() => {
+    try {
+      const raw = JSON.parse(localStorage.getItem('ts-history') || '[]');
+      return Array.isArray(raw) ? raw.slice(0, 50).filter((q) => typeof q === 'string' && q.trim()) : [];
+    } catch {
+      return [];
+    }
+  })(),
 };
 
 function buildSearchHash(query, category = 'web') {
@@ -65,6 +74,27 @@ function toggleTheme() {
   localStorage.setItem('ts-theme', isLight ? 'light' : 'dark');
 }
 
+function setHistoryEnabled(enabled) {
+  state.historyEnabled = Boolean(enabled);
+  localStorage.setItem('ts-save-history', state.historyEnabled ? '1' : '0');
+  if (!state.historyEnabled) {
+    state.searchHistory = [];
+    localStorage.removeItem('ts-history');
+  }
+}
+
+function persistHistory() {
+  if (!state.historyEnabled) return;
+  localStorage.setItem('ts-history', JSON.stringify(state.searchHistory.slice(0, 50)));
+}
+
+function addSearchToHistory(query) {
+  const q = String(query || '').trim();
+  if (!q || !state.historyEnabled) return;
+  state.searchHistory = [q, ...state.searchHistory.filter((item) => item !== q)].slice(0, 50);
+  persistHistory();
+}
+
 // ─── SVG Icons ────────────────────────────────────────────────────────────
 function svg(paths, size = 16, extra = '') {
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" ${extra}>${paths}</svg>`;
@@ -124,6 +154,23 @@ const LANGS = [
   { code: 'ja-JP', label: '🇯🇵 JA' },
 ];
 
+const AI_PRESETS = [
+  { id: 'openai', label: 'OpenAI', api_base: 'https://api.openai.com/v1', keyRequired: true, defaultModel: 'gpt-4o-mini' },
+  { id: 'chutes', label: 'Chutes.ai', api_base: 'https://llm.chutes.ai/v1', keyRequired: true, defaultModel: 'deepseek-ai/DeepSeek-V3.2-TEE' },
+  { id: 'openrouter', label: 'OpenRoute/OpenRouter', api_base: 'https://openrouter.ai/api/v1', keyRequired: true, defaultModel: 'openai/gpt-4o-mini' },
+  { id: 'anthropic', label: 'Anthropic', api_base: 'https://api.anthropic.com/v1', keyRequired: true, defaultModel: 'claude-3-5-haiku-latest' },
+  { id: 'ollama', label: 'Ollama', api_base: 'http://127.0.0.1:11434/v1', keyRequired: false, defaultModel: 'qwen3.5:4b' },
+  { id: 'lmstudio', label: 'LM Studio', api_base: 'http://127.0.0.1:1234/v1', keyRequired: false, defaultModel: '' },
+  { id: 'llamacpp', label: 'llama.cpp server', api_base: 'http://127.0.0.1:8080/v1', keyRequired: false, defaultModel: '' },
+];
+
+function detectPresetFromBase(base) {
+  const raw = String(base || '').toLowerCase();
+  if (!raw) return 'custom';
+  const preset = AI_PRESETS.find((p) => raw.startsWith(String(p.api_base).toLowerCase()));
+  return preset ? preset.id : 'custom';
+}
+
 function LangPicker() {
   const wrap = el('div', { className: 'lang-wrap' });
   const sel  = el('select', { className: 'lang-select' });
@@ -142,13 +189,20 @@ function LangPicker() {
 function SearchForm(value, onSearch) {
   const form  = el('form', { className: 'search-form' });
   const sicon = el('span', { className: 'search-icon', html: ICONS.search });
+  const listId = `search-history-list-${Math.random().toString(36).slice(2, 8)}`;
   const input = el('input', {
     className: 'search-input', type: 'search',
     placeholder: 'Search...', value: value || '',
     autocomplete: 'off', autocorrect: 'off', autocapitalize: 'off', spellcheck: 'false',
+    ...(state.historyEnabled ? { list: listId } : {}),
   });
   const btn = el('button', { className: 'search-btn', type: 'submit', html: ICONS.search });
   form.append(sicon, input, btn);
+  if (state.historyEnabled && state.searchHistory.length) {
+    const dl = el('datalist', { id: listId });
+    state.searchHistory.slice(0, 12).forEach((q) => dl.append(el('option', { value: q })));
+    form.append(dl);
+  }
   form.addEventListener('submit', (e) => {
     e.preventDefault();
     const q = input.value.trim();
@@ -531,6 +585,7 @@ async function runSearchProgressive(q, lang, category) {
 
 async function doSearch(q, category = state.category) {
   if (!q.trim()) return;
+  addSearchToHistory(q);
   state.category = ['web', 'images', 'news'].includes(category) ? category : 'web';
   state.loading = true;
   state.results = [];
@@ -728,7 +783,10 @@ function renderApp() {
 function renderHome(app) {
   const home = el('div', { className: 'home' },
     el('div', { className: 'home-logo' }, 'Term', el('strong', {}, 'Search')),
-    el('div', { className: 'home-tagline' }, 'Personal search engine · privacy-first · local-first'),
+    el('div', { className: 'home-tagline' },
+      el('span', { className: 'tagline-desktop' }, 'Personal search engine · privacy-first · local-first'),
+      el('span', { className: 'tagline-mobile' }, 'Private search · local-first'),
+    ),
     el('div', { className: 'home-search' }, SearchForm('', (q) => { state.query = q; state.category = 'web'; doSearch(q, 'web'); })),
     el('div', { className: 'home-actions' },
       LangPicker(),
@@ -767,6 +825,7 @@ async function renderSettings() {
   const brave  = cfg.brave  || {};
   const mojeek = cfg.mojeek || {};
   const searxng = cfg.searxng || {};
+  const detectedPreset = detectPresetFromBase(ai.api_base);
 
   const header = el('div', { className: 'header' },
     el('button', { className: 'btn', onClick: () => history.back() }, iconEl('back'), ' Back'),
@@ -788,11 +847,119 @@ async function renderSettings() {
   }
 
   const saveAlertEl = el('div', { style: 'display:none' });
+  const aiModelStatus = el('div', { id: 'ai-model-status', style: 'display:none' });
+  const historyInfoEl = el('div', { id: 'history-preview', className: 'form-hint', style: 'margin-top:8px' });
+  const presetSelect = el('select', { className: 'form-input', id: 'ai-preset' });
+  presetSelect.append(el('option', { value: 'custom' }, 'Custom'));
+  AI_PRESETS.forEach((preset) => {
+    const opt = el('option', { value: preset.id }, preset.label);
+    if (preset.id === detectedPreset) opt.selected = true;
+    presetSelect.append(opt);
+  });
+  const modelInput = makeInput('ai-model', ai.model, 'qwen3.5:4b');
+  modelInput.setAttribute('list', 'ai-model-list');
+  const modelDataList = el('datalist', { id: 'ai-model-list' });
+
+  function setModelStatus(message, type = 'info') {
+    aiModelStatus.style.display = 'block';
+    aiModelStatus.className = `alert alert-${type}`;
+    aiModelStatus.textContent = message;
+  }
+
+  function renderHistoryPreview() {
+    if (!state.historyEnabled) {
+      historyInfoEl.textContent = 'Search history disabled.';
+      return;
+    }
+    if (!state.searchHistory.length) {
+      historyInfoEl.textContent = 'No searches saved yet.';
+      return;
+    }
+    historyInfoEl.textContent = `Recent: ${state.searchHistory.slice(0, 8).join(' · ')}`;
+  }
+
+  function populateModelList(models) {
+    modelDataList.innerHTML = '';
+    for (const model of models) {
+      modelDataList.append(el('option', { value: model }));
+    }
+  }
+
+  async function loadModels(trigger = 'manual') {
+    const base = val('ai-base');
+    const key = val('ai-key');
+    const presetId = val('ai-preset');
+    if (!base) {
+      setModelStatus('Set API endpoint first.', 'info');
+      return;
+    }
+    const preset = AI_PRESETS.find((p) => p.id === presetId);
+    if (preset?.keyRequired && !key) {
+      setModelStatus(`Insert API key for ${preset.label} to load models.`, 'info');
+      return;
+    }
+
+    const btn = document.getElementById('ai-load-models-btn');
+    if (btn) btn.disabled = true;
+    setModelStatus('Loading models…', 'info');
+    try {
+      const res = await api('/api/config/models', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ api_base: base, api_key: key, preset: presetId }),
+      });
+      const models = Array.isArray(res.models) ? res.models : [];
+      if (!models.length) {
+        setModelStatus(`No models found${res.provider ? ` for ${res.provider}` : ''}.`, 'err');
+        return;
+      }
+      populateModelList(models);
+      const current = val('ai-model');
+      if (!current || !models.includes(current)) {
+        const modelField = document.getElementById('ai-model');
+        if (modelField) modelField.value = models[0];
+      }
+      setModelStatus(`Loaded ${models.length} model(s)${res.provider ? ` from ${res.provider}` : ''}.`, 'ok');
+    } catch (e) {
+      setModelStatus(`Model load failed: ${e.message}`, 'err');
+    } finally {
+      if (btn) btn.disabled = false;
+      if (trigger === 'manual') {
+        setTimeout(() => { aiModelStatus.style.display = 'none'; }, 4500);
+      }
+    }
+  }
+
+  function applyPreset() {
+    const presetId = val('ai-preset');
+    const preset = AI_PRESETS.find((p) => p.id === presetId);
+    const hintEl = document.getElementById('ai-preset-hint');
+    if (!preset) {
+      if (hintEl) hintEl.textContent = 'Custom endpoint mode.';
+      return;
+    }
+    const baseField = document.getElementById('ai-base');
+    const modelField = document.getElementById('ai-model');
+    if (baseField) baseField.value = preset.api_base;
+    if (modelField && (!modelField.value || modelField.value === ai.model) && preset.defaultModel) {
+      modelField.value = preset.defaultModel;
+    }
+    if (hintEl) {
+      hintEl.textContent = preset.keyRequired
+        ? `Preset ready: insert API key for ${preset.label}, then load models.`
+        : `Preset ready: local endpoint (${preset.label}).`;
+    }
+    if (!preset.keyRequired || val('ai-key')) {
+      loadModels('preset');
+    }
+  }
 
   async function saveSettings() {
     const aiKey = val('ai-key');
     const braveKey = val('brave-key');
     const mojeekKey = val('mojeek-key');
+    setHistoryEnabled(isChecked('history-enabled'));
+    renderHistoryPreview();
     const update = {
       ai: {
         api_base: val('ai-base'),
@@ -920,15 +1087,23 @@ async function renderSettings() {
     el('div', { className: 'settings-section' },
       el('h2', {}, 'AI Configuration (optional)'),
       el('div', { className: 'alert alert-info', style: 'margin-bottom:12px;font-size:11px' },
-        'Any OpenAI-compatible endpoint: Ollama, LM Studio, Groq, OpenAI, Z.AI, Chutes.ai…'
+        'Preset ready: just set key (if required), load models, save.'
+      ),
+      el('div', { className: 'form-group' },
+        el('label', { className: 'form-label', for: 'ai-preset' }, 'Preset'),
+        presetSelect,
+        el('div', { className: 'form-row', style: 'margin-top:6px' },
+          el('button', { id: 'ai-preset-apply-btn', className: 'btn', onClick: applyPreset, type: 'button' }, 'Apply preset'),
+          el('span', { id: 'ai-preset-hint', className: 'form-hint', style: 'margin-top:0' }, 'Select a preset to prefill endpoint/model.'),
+        ),
       ),
       el('div', { className: 'form-group' },
         el('label', { className: 'form-label', for: 'ai-base' }, 'API Endpoint'),
         makeInput('ai-base', ai.api_base, 'http://localhost:11434/v1'),
         el('div', { className: 'form-hint' },
-          'Localhost: localhost:11434/v1 (Ollama) · localhost:1234/v1 (LM Studio)',
+          'Included presets: Chutes.ai · Anthropic · OpenAI · OpenRoute/OpenRouter · llama.cpp · Ollama · LM Studio',
           el('br', {}),
-          'Chutes/OpenAI-compatible: llm.chutes.ai/v1 · OpenAI: api.openai.com/v1',
+          'You can also keep custom OpenAI-compatible endpoints.',
         ),
       ),
       el('div', { className: 'form-group' },
@@ -938,11 +1113,13 @@ async function renderSettings() {
       ),
       el('div', { className: 'form-group' },
         el('label', { className: 'form-label', for: 'ai-model' }, 'Model'),
-        makeInput('ai-model', ai.model, 'qwen3.5:4b'),
-        el('div', { className: 'form-hint' },
-          'Localhost: qwen3.5:4b, llama3.2, mistral… · Chutes: deepseek-ai/DeepSeek-V3.2-TEE',
-          el('br', {}), 'OpenAI: gpt-4o-mini',
+        modelInput,
+        modelDataList,
+        el('div', { className: 'form-row', style: 'margin-top:6px' },
+          el('button', { id: 'ai-load-models-btn', className: 'btn', onClick: () => loadModels('manual'), type: 'button' }, 'Load models'),
+          el('span', { className: 'form-hint', style: 'margin-top:0' }, 'Auto-loads from endpoint with current key.'),
         ),
+        aiModelStatus,
       ),
       el('div', { className: 'form-row', style: 'margin-top:4px' },
         el('button', { id: 'ai-test-btn', className: 'btn btn-primary', onClick: testAi }, 'Test Connection'),
@@ -951,6 +1128,31 @@ async function renderSettings() {
       el('div', { id: 'ai-test-result', style: 'display:none' }),
     ),
 
+    // Search history
+    el('div', { className: 'settings-section' },
+      el('h2', {}, 'Search History'),
+      el('div', { className: 'toggle-row' },
+        el('span', { className: 'toggle-label' }, 'Save search history'),
+        el('label', { className: 'toggle' },
+          el('input', { type: 'checkbox', id: 'history-enabled', ...(state.historyEnabled ? { checked: '' } : {}) }),
+          el('span', { className: 'toggle-slider' }),
+        ),
+      ),
+      historyInfoEl,
+      el('div', { style: 'margin-top:10px;display:flex;gap:8px;align-items:center' },
+        el('button', {
+          className: 'btn',
+          type: 'button',
+          onClick: () => {
+            state.searchHistory = [];
+            localStorage.removeItem('ts-history');
+            renderHistoryPreview();
+          },
+        }, 'Clear history'),
+        el('button', { className: 'btn btn-primary', onClick: saveSettings, type: 'button' }, 'Save preference'),
+      ),
+    ),
+
     // Providers
     el('div', { className: 'settings-section' },
       el('h2', {}, 'Search Providers'),
@@ -1014,7 +1216,7 @@ async function renderSettings() {
     // Server info
     el('div', { className: 'settings-section' },
       el('h2', {}, 'Server Info'),
-      el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'Version'),          el('span', { className: 'info-val' }, health?.version || '0.3.0')),
+      el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'Version'),          el('span', { className: 'info-val' }, health?.version || '0.3.1')),
       el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'Active providers'), el('span', { className: 'info-val' }, (health?.providers || []).join(', ') || 'none')),
       el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'AI'),               el('span', { className: 'info-val' }, health?.ai_enabled ? `enabled (${health.ai_model})` : 'not configured')),
       el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'GitHub'),           el('a', { href: 'https://github.com/DioNanos/termsearch', target: '_blank', className: 'info-val', style: 'color:var(--link)' }, 'DioNanos/termsearch')),
@@ -1041,6 +1243,26 @@ async function renderSettings() {
   );
 
   app.append(header, main);
+  renderHistoryPreview();
+  document.getElementById('history-enabled')?.addEventListener('change', (e) => {
+    setHistoryEnabled(Boolean(e.target?.checked));
+    renderHistoryPreview();
+  });
+  document.getElementById('ai-key')?.addEventListener('change', () => loadModels('auto'));
+  document.getElementById('ai-base')?.addEventListener('change', () => loadModels('auto'));
+  presetSelect.addEventListener('change', applyPreset);
+  if (detectedPreset && detectedPreset !== 'custom') {
+    const hintEl = document.getElementById('ai-preset-hint');
+    const preset = AI_PRESETS.find((p) => p.id === detectedPreset);
+    if (hintEl && preset) {
+      hintEl.textContent = preset.keyRequired
+        ? `Preset detected: ${preset.label}. Insert key and load models.`
+        : `Preset detected: ${preset.label}.`;
+    }
+  }
+  if (ai.api_base && (!AI_PRESETS.find((p) => p.id === detectedPreset)?.keyRequired)) {
+    loadModels('auto');
+  }
 }
 
 // ─── Bootstrap ────────────────────────────────────────────────────────────

package/frontend/dist/style.css

@@ -192,6 +192,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; }
@@ -748,6 +752,9 @@ a:hover { color: var(--link-h); }
   .cat-tab { font-size: 10px; padding: 4px 8px; }
   .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.1",
   "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

@@ -11,7 +11,7 @@ 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.1';
 const ALLOWED_CATEGORIES = new Set(['web', 'images', 'news']);
 
 function parseCategory(raw) {
@@ -31,6 +31,96 @@ function parseEngines(raw) {
   )];
 }
 
+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 && 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';
+}
+
+async function fetchOpenAiCompatibleModels(base, apiKey, timeoutMs = 10000) {
+  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(`${base}/models`, { headers, signal: ac.signal });
+    if (!response.ok) return [];
+    const payload = await response.json();
+    return (payload?.data || [])
+      .map((item) => String(item?.id || '').trim())
+      .filter(Boolean);
+  } 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 (payload?.data || [])
+      .map((item) => String(item?.id || '').trim())
+      .filter(Boolean);
+  } 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) {
   const router = express.Router();
 
@@ -68,6 +158,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' } },
       },
     });
   });
@@ -305,6 +396,36 @@ 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 === 'ollama') {
+      models = await fetchOllamaModels(base);
+      if (models.length === 0) {
+        models = await fetchOpenAiCompatibleModels(base, apiKey);
+      }
+    } else {
+      models = await fetchOpenAiCompatibleModels(base, apiKey);
+    }
+
+    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();