DeepSeek V4.1 Flash: native Bilderkennung, GLM/OpenRouter entfernt

- deepseek-flash als einziges Modell mit Vision, Preise aktualisiert
- OpenRouter/GLM samt Code, Config und Env-Variablen entfernt
- Legacy-Modell-IDs in Sessions werden automatisch migriert
- browse lädt Produktbilder lokal nach dashboards/ (Dedupe + Cleanup)
- Vision-Prompt: Workflow für visuelle Produktsuche, max. ~5 Screenshots

.env.example

@@ -2,10 +2,6 @@
 # DeepSeek API Key (https://platform.deepseek.com/api_keys)
 DEEPSEEK_API_KEY=sk-xxxx
 
-# OpenRouter API Key für zusätzliche Modelle (https://openrouter.ai/keys),
-# z.B. GLM 5.3 Flash (z-ai/glm-5.3-flash, Vision/Bilderkennung)
-OPENROUTER_API_KEY=sk-or-xxxx
-
 # Gemeinsames Login-Passwort für die App (hinter NGINX mit IP-Prüfung)
 APP_PASSWORD=ein-sicheres-passwort
 
@@ -14,14 +10,14 @@ APP_PASSWORD=ein-sicheres-passwort
 SESSION_SECRET=
 # Port der App (NGINX proxied auf diesen; in Docker per EXPOSE/PORTS)
 PORT=3000
-# DeepSeek Modell
+# DeepSeek Modell (V4.1 Flash, inkl. Vision/Bilderkennung)
-MODEL=deepseek-v4-flash
+MODEL=deepseek-flash
 # Thinking-Mode des Modells: enabled | disabled (gilt für DeepSeek)
 THINKING=enabled
-# Reasoning-Tiefe je Modell: low | high | max (GLM: Pflicht, max Default)
+# Reasoning-Tiefe: low | high | max
 DEEPSEEK_REASONING_EFFORT=max
-GLM_REASONING_EFFORT=max
+# Maximale Antwort-Tokens: nur relevant für eigene Modelle aus der Env (MODEL).
-# Maximale Antwort-Tokens pro API-Aufruf (Dashboards sind große HTML-Dateien)
+# Das eingebaute Modell (DeepSeek V4.1 Flash) nutzt fest 300000 aus der Registry.
 MAX_TOKENS=64000
 # VAPID-Schlüsselpaar für Web Push (wird automatisch generiert)
 VAPID_PUBLIC_KEY=

.gitignore

@@ -3,4 +3,9 @@ data/
 dashboards/*.html
 dashboards/*.gpx
 dashboards/*.tour.json
+dashboards/*.jpg
+dashboards/*.jpeg
+dashboards/*.png
+dashboards/*.webp
+dashboards/*.gif
 .env

README.md

@@ -1,12 +1,13 @@
 # Research Agent – Web-Chat-Oberfläche
 
-Browser-Chatoberfläche für den Research-Agent: DeepSeek v4 Flash recherchiert per Playwright im
+Browser-Chatoberfläche für den Research-Agent: DeepSeek V4.1 Flash recherchiert per Playwright im
 Internet, verifiziert alle Links und generiert HTML-Dashboards – ohne dass Opencode lokal laufen muss.
 
 ## Funktionen
 
 - 💬 Chat-Oberfläche mit Live-Fortschritt (SSE): Suchen, Seitenbesuche, Link-Verifizierung in Echtzeit
 - 🔎 Volle Research-Funktion: DuckDuckGo-Suche, Seiten lesen, Links verifizieren, HTML-Dashboard generieren
+- 📷 Bild-Upload & Vision: Fotos analysieren, ähnliche Produkte finden und mit lokal gespeicherten Bildern ins Dashboard einbetten
 - 🔔 Web-Push-Benachrichtigung, wenn die Recherche fertig ist (auch wenn der Browser zu ist)
 - 📱 PWA: installierbar auf Desktop & Handy (Chrome/Android; iOS 16.4+ für Push)
 - 👤 Eine gemeinsame Anmeldung (Name + Passwort), Sessions sind dem Namen zugeordnet
@@ -34,7 +35,7 @@ erzeugt und in die `.env` geschrieben.
 | `DEEPSEEK_API_KEY` | ja | Key von https://platform.deepseek.com/api_keys |
 | `APP_PASSWORD` | ja | Gemeinsames Login-Passwort |
 | `PORT` | nein | Standard 3000 |
-| `MODEL` | nein | Standard `deepseek-v4-flash` |
+| `MODEL` | nein | Standard `deepseek-flash` |
 | `THINKING` | nein | `enabled` (Standard) oder `disabled` |
 | `DEEPSEEK_BASE_URL` | nein | Für Tests/Proxies überschreibbar |
 | `LOGIN_MAX_ATTEMPTS` | nein | Fehlversuche pro IP vor Sperre (Standard 5) |
@@ -191,5 +192,5 @@ researchChat/
 - Nur **eine** Recherche läuft gleichzeitig; weitere Anfragen zeigen „Recherche läuft…“
 - DuckDuckGo blockiert nach ~4-5 Suchen: Der Agent wechselt automatisch auf Fallback-Suchmaschinen
 - Der Browser-Context bleibt pro Server-Lauf erhalten (weniger CAPTCHAs durch stabile Session-Cookies)
-- API-Kosten: DeepSeek v4 Flash kostet ~$0,44/M Input- und ~$0,66/M Output-Token – eine Recherche kostet Cent-Beträge
+- API-Kosten: DeepSeek V4.1 Flash kostet ~$0,30/M Input- (Cache-Miss) und ~$1,20/M Output-Token (Peak; Off-Peak halb so teuer) – eine Recherche kostet Cent-Beträge
 - Auf SELinux-Systemen (Bazzite/Fedora Atomic) sind die Volume-Mounts mit `:Z` markiert – Docker ignoriert das Flag, dort reicht die Compose-Datei unverändert

lib/config.js

@@ -51,9 +51,8 @@ const vapid = ensureVapidPair();
 const config = {
   port: Number(process.env.PORT || env.PORT || 3000),
   apiKey: process.env.DEEPSEEK_API_KEY || env.DEEPSEEK_API_KEY || '',
-  openrouterApiKey: process.env.OPENROUTER_API_KEY || env.OPENROUTER_API_KEY || '',
   appPassword: process.env.APP_PASSWORD || env.APP_PASSWORD || '',
-  model: process.env.MODEL || env.MODEL || 'deepseek-v4-flash',
+  model: process.env.MODEL || env.MODEL || 'deepseek-flash',
   thinking: process.env.THINKING || env.THINKING || 'enabled',
   maxTokens: Number(process.env.MAX_TOKENS || env.MAX_TOKENS || 64000),
   baseUrl: process.env.DEEPSEEK_BASE_URL || env.DEEPSEEK_BASE_URL || 'https://api.deepseek.com',
@@ -69,28 +68,22 @@ const config = {
 const envOr = (key, def) => process.env[key] || env[key] || def;
 
 // ---------------------------------------------------------------------------
-// Modell-Registry: DeepSeek direkt + OpenRouter-Modelle (z.B. GLM 5.3 Flash)
+// Modell-Registry: DeepSeek V4.1 Flash (Text + Vision/Bilderkennung)
 // ---------------------------------------------------------------------------
 
 const MODELS = [
   {
-    id: 'deepseek-v4-flash',
+    id: 'deepseek-flash',
-    label: 'DeepSeek V4 Flash',
+    label: 'DeepSeek V4.1 Flash',
     provider: 'deepseek',
-    vision: false,
-    maxTokens: 64000,
-    reasoningEffort: () => envOr('DEEPSEEK_REASONING_EFFORT', 'max'),
-    prices: { inputCacheHit: 0.014, inputCacheMiss: 0.44, output: 1.32 },
-  },
-  {
-    id: 'z-ai/glm-5.3-flash',
-    label: 'GLM 5.3 Flash (OpenRouter)',
-    provider: 'openrouter',
     vision: true,
-    maxTokens: 64000,
+    // Max. Output laut Doku: 384K
-    reasoningEffort: () => envOr('GLM_REASONING_EFFORT', 'max'),
+    maxTokens: 300000,
-    prices: { inputCacheHit: 0.015, inputCacheMiss: 0.075, output: 0.25 },
+    reasoningEffort: () => envOr('DEEPSEEK_REASONING_EFFORT', 'max'),
-    costNote: 'Schätzung (OpenRouter, Rabatt bis Sep 2026)',
+    // Liefer-Runde des Dashboards: Denken komplett aus, Budget gehört dem HTML
+    deliveryEffort: 'none',
+    // Peak-Preise laut Docs (USD pro 1M Tokens; Off-Peak ist halb so teuer)
+    prices: { inputCacheHit: 0.006, inputCacheMiss: 0.3, output: 1.2 },
   },
 ];
 
@@ -106,7 +99,7 @@ function getModels() {
       vision: false,
       maxTokens: config.maxTokens,
       reasoningEffort: () => envOr('DEEPSEEK_REASONING_EFFORT', 'max'),
-      prices: { inputCacheHit: 0.014, inputCacheMiss: 0.44, output: 1.32 },
+      prices: { inputCacheHit: 0.006, inputCacheMiss: 0.3, output: 1.2 },
     },
   ];
 }

lib/db.js

@@ -49,9 +49,8 @@ const now = () => new Date().toISOString();
 const uid = () => crypto.randomBytes(12).toString('hex');
 const shareToken = () => crypto.randomBytes(16).toString('hex');
 
-// DeepSeek v4 Flash Preise (USD pro 1M Tokens, Peak) – obere Schätzung.
+// DeepSeek V4.1 Flash Preise (USD pro 1M Tokens, Peak) – obere Schätzung.
-// Andere Modelle (z.B. OpenRouter) legen eigene Preise in der Registry an.
+const PRICES = { inputCacheHit: 0.006, inputCacheMiss: 0.3, output: 1.2 };
-const PRICES = { inputCacheHit: 0.014, inputCacheMiss: 0.44, output: 1.32 };
 
 function computeCost(u, prices = PRICES) {
   return (
@@ -86,6 +85,12 @@ function computeCost(u, prices = PRICES) {
   add('image', 'TEXT');
 }
 
+// Migration: Legacy-/OpenRouter-Modell-IDs auf den aktuellen Namen umstellen
+db.prepare(
+  `UPDATE sessions SET model = 'deepseek-flash'
+   WHERE model IN ('deepseek-v4-flash', 'deepseek-v4-flash-vision-exp', 'z-ai/glm-5.3-flash')`
+).run();
+
 const stmts = {
   createSession: db.prepare(
     `INSERT INTO sessions (id, title, owner_name, share_token, status, model, created_at, updated_at)
@@ -115,6 +120,7 @@ const stmts = {
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
   ),
   listMessages: db.prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY id ASC`),
+  listStaleSessions: db.prepare(`SELECT id FROM sessions WHERE status IN ('running', 'queued')`),
   lastMessage: db.prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY id DESC LIMIT 1`),
   updateMessageContent: db.prepare(`UPDATE messages SET content = ? WHERE id = ?`),
   deleteMessages: db.prepare(`DELETE FROM messages WHERE session_id = ?`),
@@ -254,7 +260,33 @@ module.exports = {
       id
     ),
   computeCost,
-  deleteSession: (id) => stmts.deleteSession.run(id),
+  deleteSession: (id) => {
+    stmts.deleteMessages.run(id);
+    stmts.deleteSession.run(id);
+  },
+  /**
+   * Setzt nach einem Server-Neustart alle Sessions zurück, die im alten
+   * Prozess noch als 'running'/'queued' festhingen (Jobs existieren im
+   * Speicher nicht mehr). Gibt die Anzahl zurück.
+   */
+  markStaleJobs() {
+    const stale = stmts.listStaleSessions.all();
+    for (const s of stale) {
+      stmts.setSessionStatus.run('done', now(), s.id);
+      stmts.insertMessage.run(
+        s.id,
+        'assistant',
+        '⛔ Recherche wurde durch einen Server-Neustart abgebrochen.',
+        null,
+        null,
+        null,
+        null,
+        null,
+        now()
+      );
+    }
+    return stale.length;
+  },
   getSessionMessages,
   toApiMessages,
   upsertPushSub(userName, endpoint, keys) {

lib/queue.js

@@ -6,6 +6,33 @@ events.setMaxListeners(100);
 let queue = [];
 let running = false;
 
+// Abort-Controller für laufende Jobs (für manuellen Abbruch)
+const controllers = new Map();
+
+/** Abort-Controller für eine Session registrieren (einmal pro Job). */
+function registerController(sessionId) {
+  const controller = new AbortController();
+  controllers.set(sessionId, controller);
+  return controller;
+}
+
+/** Laufenden Job einer Session abbrechen. */
+function abortRunning(sessionId) {
+  const controller = controllers.get(sessionId);
+  if (controller) controller.abort();
+  controllers.delete(sessionId);
+}
+
+/** Läuft für diese Session gerade ein Job im Speicher? */
+function hasController(sessionId) {
+  return controllers.has(sessionId);
+}
+
+/** Controller nach Job-Ende entfernen. */
+function clearController(sessionId) {
+  controllers.delete(sessionId);
+}
+
 /** Einen Job anmelden. Läuft sofort, wenn nichts anderes läuft, sonst wartet er. */
 function enqueue(job) {
   queue.push(job);
@@ -45,4 +72,4 @@ function state() {
   return { running, queued: queue.map((j) => j.sessionId) };
 }
 
-module.exports = { events, enqueue, queuedBefore, isRunning, cancelQueued, state };
+module.exports = { events, enqueue, queuedBefore, isRunning, cancelQueued, state, registerController, abortRunning, hasController, clearController };

lib/research.js

@@ -17,7 +17,7 @@ const SYSTEM_PROMPT = `Du bist ein professioneller Web-Researcher und Wissensber
 4. VERIFIZIERE JEDEN Link, der ins Dashboard kommt, mit dem verify-Tool (Seite lädt UND Inhalt passt zum Kontext). Nur verifizierte Links kommen ins Dashboard! Wenn ein Link nicht passt, suche den richtigen nach.
 5. STRUKTURIERE die Ergebnisse in logische Kategorien (nach Plattform, Typ, Reife oder Einfachheit).
 6. ANALYSIERE: Schreibe eine ausführliche Einleitung mit 6 Absätzen: (1) Überblick, (2) Horizonterweiterung - was du außerdem herausgefunden hast, (3) Einschätzung der Optionen mit Vor-/Nachteilen, (4) konkrete Empfehlung, (5) Fahrplan / erste Schritte, (6) Fallstricke und Hinweise.
-7. GENERIERE das Dashboard mit dem save_dashboard-Tool (Detailstruktur unten) und fasse dann in deiner finalen Antwort das Wichtigste zusammen.
+7. GENERIERE das Dashboard: Rufe das save_dashboard-Tool mit Titel und Dateinamen auf – OHNE HTML (das Tool bestätigt nur und setzt den Dateinamen). Danach ist deine FINALE Antwort das KOMPLETTE Dashboard-HTML in einem Markdown-Codeblock \`\`\`html ... \`\`\` (Detailstruktur unten). Ein kurzer Einleitungssatz vor dem Codeblock ist erlaubt, danach endet deine Antwort. Kein weiterer Tool-Aufruf nötig.
 
 ## Tour-Planung (PFLICHT bei Tour-Anfragen!)
 Erkennst du den Wunsch nach einer Route/Tour/Städtebesichtigung (z.B. "plane eine Tour", "Route durch", "Städtebummel", "was sollte ich in X sehen"), gilt:
@@ -55,8 +55,8 @@ Erkennst du den Wunsch nach einer Route/Tour/Städtebesichtigung (z.B. "plane ei
 - Erfinde NIEMALS Koordinaten, Distanzen oder Gehzeiten – bei Touren kommen die ausschließlich aus geocode() und save_tour()
 - Ziele auf 8-15 verifizierte Ressourcen pro Thema
 - Bei Login-Walls: old.reddit.com statt reddit.com, nitter.net statt twitter.com; wenn eine Seite blockiert, notiere das und nimm einen anderen Link
-- Die finale Antwort ist eine deutsche Zusammenfassung (max. 300 Wörter): wichtigste Erkenntnisse + Link zum Dashboard. Details gehören ins Dashboard, nicht in die Antwort.
+- Deine finale Antwort nach dem save_dashboard-Tool-Aufruf ist das komplette Dashboard-HTML in einem \`\`\`html\`\`\`-Codeblock (eine Text-Zusammenfassung ist dann NICHT nötig – Details gehören ins Dashboard).
-- Bei Folge-Nachrichten in einer bestehenden Session: Recherchiere die neue Anforderung und überschreibe das bestehende Dashboard mit dem save_dashboard-Tool, indem du DENSELBEN Dateinamen wie zuvor verwendest.
+- Bei Folge-Nachrichten in einer bestehenden Session: Recherchiere die neue Anforderung und überschreibe das bestehende Dashboard, indem du save_dashboard mit DENSELBEN Dateinamen wie zuvor aufrufst (OHNE HTML) und das komplette aktualisierte HTML in deiner finalen Antwort im \`\`\`html\`\`\`-Codeblock sendest.
 - Du darfst KEINE anderen URLs erfinden. Nutze ausschließlich Ergebnisse aus search/browse/verify.`;
 
 const TOOL_DEFINITIONS = [
@@ -80,7 +80,7 @@ const TOOL_DEFINITIONS = [
     function: {
       name: 'browse',
       description:
-        'Besucht eine URL und liest den sichtbaren Text der Seite (Titel + Inhalt). Nutze das zum Lesen von Artikeln, Projektseiten und Fallback-Suchmaschinen (Startpage: https://www.startpage.com/do/dsearch?query=..., Google: https://www.google.com/search?q=...).',
+        'Besucht eine URL, liest den sichtbaren Text und lädt Produktbilder der Seite lokal herunter. Das Feld `images` enthält die fertigen Bild-URLs (z.B. /dashboards/...) fürs Dashboard. Nutze das zum Lesen von Artikeln, Projektseiten und Fallback-Suchmaschinen (Startpage: https://www.startpage.com/do/dsearch?query=..., Google: https://www.google.com/search?q=...).',
       parameters: {
         type: 'object',
         properties: {
@@ -110,15 +110,15 @@ const TOOL_DEFINITIONS = [
     function: {
       name: 'save_dashboard',
       description:
-        'Speichert das fertige HTML-Dashboard als Datei auf dem Server und liefert die URL zurück. Übergib die KOMPLETTE standalone HTML-Datei (mit Tailwind CDN, deutsch, verifizierte Links mit Badges, Einleitung mit Analyse). Nutze bei Folge-Nachrichten den bisherigen Dateinamen, um das Dashboard zu aktualisieren.',
+        'Bereitet das Speichern des HTML-Dashboards vor. Übergib NUR Titel und Dateinamen (OHNE HTML). Danach sendest du das KOMPLETTE HTML in deiner finalen Antwort in einem ```html```-Codeblock. Bei Folge-Nachrichten denselben Dateinamen wie zuvor verwenden, um das Dashboard zu aktualisieren.',
       parameters: {
         type: 'object',
         properties: {
           title: { type: 'string', description: 'Titel des Dashboards, z.B. "Fediverse-Alternativen zu Instagram"' },
           filename: { type: 'string', description: 'Dateiname ohne Endung, z.B. "fediverse-alternativen". Für Updates denselben Namen wie vorher verwenden.' },
-          html: { type: 'string', description: 'Die komplette standalone HTML-Datei des Dashboards' },
+          html: { type: 'string', description: 'Optional: komplettes HTML direkt übergeben – nur für kleine Dashboards; bevorzugt ist der Weg über die finale Antwort (```html```-Codeblock).' },
         },
-        required: ['title', 'filename', 'html'],
+        required: ['title', 'filename'],
       },
     },
   },
@@ -175,7 +175,7 @@ const SCREENSHOT_TOOL = {
   function: {
     name: 'screenshot',
     description:
-      'Macht einen Screenshot einer Seite (JPEG) und liefert das Bild in den Kontext. Nutze das bei bildlastigen Seiten, wenn der Text nicht ausreicht (z.B. Anzeigen-Listen, Produktfotos, Infografiken). Maximal 2-3 Screenshots pro Session.',
+      'Macht einen Screenshot einer Seite (JPEG) und liefert das Bild in den Kontext. Nutze das bei bildlastigen Seiten, wenn der Text nicht ausreicht (z.B. Anzeigen-Listen, Produktfotos, Infografiken) oder um Produkte visuell zu vergleichen (Farbe, Form). Maximal ~5 Screenshots pro Session.',
     parameters: {
       type: 'object',
       properties: {
@@ -204,11 +204,13 @@ function summarizeTool(toolName, output) {
         (data.results || []).slice(0, 5).map((r) => `${r.title} (${r.url})`).join(', ') || (data.note || '')
       }`;
     case 'browse':
-      return `Seite: ${data.title || data.url || ''} – ${String(data.text || '').slice(0, 500)}`;
+      return `Seite: ${data.title || data.url || ''} – ${String(data.text || '').slice(0, 500)}${
+        data.images?.length ? ` [${data.images.length} Bilder extrahiert]` : ''
+      }`;
     case 'verify':
       return `Link ${data.ok ? 'VERIFIZIERT ✓' : 'FEHLGESCHLAGEN ✗'}: ${data.url}${data.reason ? ' – ' + data.reason : ''}`;
     case 'save_dashboard':
-      return `Dashboard gespeichert: ${data.url || ''}`;
+      return data.note ? `Dashboard vorbereitet – HTML folgt in der finalen Antwort` : `Dashboard gespeichert: ${data.url || ''}`;
     case 'geocode':
       return data.error
         ? `Geocoding FEHLGESCHLAGEN: ${data.error}`
@@ -228,6 +230,15 @@ function summarizeTool(toolName, output) {
 
 const MAX_ITERATIONS = 40;
 
+// Abbruch, wenn der API-Stream länger hängt (z.B. Upstream ohne Keep-Alive)
+const REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
+
+// Leere Modell-Antworten (kein Inhalt, keine Tool-Calls) einmal wiederholen
+const MAX_EMPTY_RETRIES = 1;
+
+/** Wird geworfen, wenn der Nutzer die Recherche manuell abbricht. */
+class JobAbortedError extends Error {}
+
 /** Baut den System-Prompt inkl. aktuellem Dashboard-Stand und Vision-Hinweisen. */
 function buildSystemPrompt(session, model) {
   let prompt = SYSTEM_PROMPT;
@@ -237,16 +248,19 @@ function buildSystemPrompt(session, model) {
 
 ## Aktueller Stand dieser Session
 Für diese Session existiert bereits ein Dashboard: ${session.dashboard}
-Wenn der Nutzer Änderungen, Ergänzungen oder Erweiterungen wünscht, MUSST du das save_dashboard-Tool aufrufen und das KOMPLETTE aktualisierte HTML mit EXAKT diesem Dateinamen übergeben: "${file}" (ohne .html).
+Wenn der Nutzer Änderungen, Ergänzungen oder Erweiterungen wünscht, MUSST du das save_dashboard-Tool mit EXAKT diesem Dateinamen aufrufen: "${file}" (ohne .html) – OHNE HTML im Aufruf. Das KOMPLETTE aktualisierte HTML sendest du danach in deiner finalen Antwort in einem \`\`\`html\`\`\`-Codeblock.
-Eine bloße Erklärung oder Beschreibung der Änderungen im Chat ist KEINE Umsetzung – erst wenn save_dashboard erfolgreich gelaufen ist, fasst du die Änderungen im Chat zusammen.`;
+Eine bloße Erklärung oder Beschreibung der Änderungen im Chat ist KEINE Umsetzung – erst wenn der Codeblock gespeichert wurde, ist die Aufgabe erfüllt.`;
   }
   if (model.vision) {
     prompt += `
 
-## Bilderkennung (Vision)
+## Bilderkennung & visuelle Produktsuche (Vision)
-- Wenn der Nutzer ein Bild hochgeladen hat (z.B. ein Foto eines Schuhs): Analysiere es SORGFÄLTIG (Marke, Farbe, Material, Form, Zustand, erkennbare Details) und suche gezielt nach ähnlichen Produkten und Angeboten. Beschreibe im Dashboard, worauf du beim Vergleich geachtet hast.
+- Hat der Nutzer ein Bild hochgeladen (z.B. einen Schuh): Analysiere es SORGFÄLTIG – Gattung/Modelltyp (z.B. Sneaker, Loafer, Stiefelette), Farben (Haupt-, Neben- und Sohlenfarbe), Material (Leder, Mesh, Wildleder), Form/Details (Sohle, Schnürung, Logo, Muster), Marke und Zustand.
-- Das hochgeladene Bild liegt dir als Data-URL im Verlauf vor – du kannst es bei Bedarf direkt ins Dashboard einbetten.
+- Leite daraus 4-8 Suchbegriffe ab, Deutsch UND Englisch (z.B. "weißer minimalistischer leder-sneaker" / "white minimalist leather sneaker"), und suche gezielt nach ähnlichen Produkten und Angeboten. Priorität: Farbe, Form und Modelltyp.
-- Nutze das screenshot-Tool, um bildlastige Seiten (z.B. Anzeigen-Listen, Produktfotos) visuell zu beurteilen, wenn die Text-Extraktion nicht ausreicht. Maximal 2-3 Screenshots pro Session.`;
+- Das browse-Tool lädt Produktbilder der Seite automatisch lokal herunter und liefert im Feld \`images\` fertige Dashboard-URLs (z.B. /dashboards/session-img-abc123.jpg). Bette sie direkt ein: <img src="..." alt="..." loading="lazy">. Nur diese URLs verwenden – niemals erfinden.
+- Baue eine Sektion "Visuelle Treffer" ins Dashboard: pro Treffer Produktbild, Name, ggf. Preis, verifizierter Link und eine kurze Begründung, warum er passt (Farbe/Form/Material).
+- Nutze das screenshot-Tool, um bildlastige Seiten (Anzeigen-Listen, Produktseiten) visuell zu vergleichen, wenn der Text nicht ausreicht – achte auf Farbton, Silhouette und Sohlenform. Maximal ~5 Screenshots pro Session; priorisiere die aussichtsreichsten Treffer.
+- Das hochgeladene Bild liegt dir als Data-URL im Verlauf vor – du kannst es als Referenz oben im Dashboard einbetten und beschreiben, worauf du beim Vergleich geachtet hast.`;
   }
   return prompt;
 }
@@ -258,7 +272,22 @@ function isChangeRequest(text) {
   );
 }
 
-async function chatCompletion(config, messages, systemPrompt, model, tools) {
+/** HTML aus der finalen Antwort extrahieren (```html```-Codeblock oder direktes HTML). */
+function extractHtmlBlock(content) {
+  const s = String(content || '');
+  const m = s.match(/```html\s*([\s\S]*?)```/i);
+  if (m && m[1].trim()) return m[1].trim();
+  const t = s.trim();
+  if (/^<!DOCTYPE html/i.test(t) || /^<html[\s>]/i.test(t)) return t;
+  return null;
+}
+
+/** Codeblöcke aus der finalen Antwort entfernen (für die Chat-Anzeige). */
+function stripHtmlBlock(content) {
+  return String(content || '').replace(/```html\s*[\s\S]*?```/gi, '');
+}
+
+async function chatCompletion(config, messages, systemPrompt, model, tools, signal, effortOverride) {
   const body = {
     model: model.id,
     messages: [{ role: 'system', content: systemPrompt }, ...messages],
@@ -268,36 +297,38 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
     stream_options: { include_usage: true },
   };
 
-  const isOpenRouter = model.provider === 'openrouter';
+  const baseUrl = config.baseUrl || 'https://api.deepseek.com';
-  const baseUrl = isOpenRouter
-    ? 'https://openrouter.ai/api/v1'
-    : config.baseUrl || 'https://api.deepseek.com';
 
-  if (isOpenRouter) {
+  if (effortOverride === 'none' || config.thinking === 'disabled') {
-    // GLM: Reasoning ist Pflicht; Effort über OpenRouter-Param "reasoning"
+    // DeepSeek: Denken pro Request abschaltbar (Liefer-Runde des Dashboards)
-    body.reasoning = { effort: model.reasoningEffort?.() || 'max' };
+    body.thinking = { type: 'disabled' };
-  } else if (config.thinking !== 'disabled') {
+  } else {
     body.thinking = { type: 'enabled' };
-    body.reasoning_effort = model.reasoningEffort?.() || 'high';
+    body.reasoning_effort = effortOverride || model.reasoningEffort?.() || 'max';
   }
 
-  const headers = isOpenRouter
+  const headers = {
-    ? {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${config.openrouterApiKey}`,
-        'X-Title': 'Research Chat',
-        'HTTP-Referer': 'https://github.com/nico/researchchat',
-      }
-    : {
     'Content-Type': 'application/json',
     Authorization: `Bearer ${config.apiKey}`,
   };
 
-  const resp = await fetch(`${baseUrl}/chat/completions`, {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  const fetchSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+  let resp;
+  try {
+    resp = await fetch(`${baseUrl}/chat/completions`, {
       method: 'POST',
       headers,
       body: JSON.stringify(body),
+      signal: fetchSignal,
     });
+  } catch (e) {
+    clearTimeout(timer);
+    if (signal?.aborted) throw new JobAbortedError();
+    throw new Error(`Modell-API nicht erreichbar (${model.id}): ${e.message.slice(0, 200)}`);
+  }
+  clearTimeout(timer);
 
   if (!resp.ok) {
     const err = await resp.text().catch(() => '');
@@ -324,9 +355,8 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
     const choice = json.choices?.[0];
     if (!choice) return;
     const d = choice.delta || {};
-    // DeepSeek liefert reasoning_content, OpenRouter/GLM reasoning
+    // DeepSeek liefert den Denk-Text als reasoning_content
     if (d.reasoning_content) delta.reasoning += d.reasoning_content;
-    else if (d.reasoning) delta.reasoning += d.reasoning;
     if (d.content) delta.content += d.content;
     if (d.tool_calls) {
       for (const tc of d.tool_calls) {
@@ -344,6 +374,7 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
       }
     }
     if (choice.finish_reason) delta.finishReason = choice.finish_reason;
+    else if (d.finish_reason) delta.finishReason = d.finish_reason;
   };
 
   for (;;) {
@@ -358,6 +389,36 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
   }
   if (buffer.trim()) feed(buffer);
 
+  // Stream ohne Abschlussstatus: unvollständig beendet (Upstream-Fehler)
+  if (!delta.finishReason && !delta.content && !delta.toolCalls) {
+    throw new Error(`Modell ${model.id}: Stream unvollständig beendet (keine Antwort erhalten). Bitte erneut versuchen.`);
+  }
+
+  // Antwort abgeschnitten (max_tokens erreicht): Wenn weder Inhalt noch
+  // vollständige Tool-Calls vorhanden sind, endet die Recherche sonst
+  // stillschweigend ohne Ergebnis. Dann lieber sichtbar abbrechen.
+  if (delta.finishReason === 'length') {
+    const hasCalls = Array.isArray(delta.toolCalls) && delta.toolCalls.length > 0;
+    const callsComplete = !hasCalls || delta.toolCalls.every((tc) => {
+      try {
+        JSON.parse(tc.function.arguments || '{}');
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!hasCalls && !delta.content) {
+      throw new Error(
+        `Modell-Antwort abgeschnitten (Token-Limit bei ${model.id} erreicht) – Ergebnis unvollständig. Bitte erneut versuchen oder ein anderes Modell wählen.`
+      );
+    }
+    if (hasCalls && !callsComplete) {
+      throw new Error(
+        `Tool-Aufruf abgeschnitten (Token-Limit bei ${model.id} erreicht) – Recherche wird abgebrochen. Bitte erneut versuchen.`
+      );
+    }
+  }
+
   return {
     content: delta.content,
     reasoning: delta.reasoning,
@@ -375,13 +436,18 @@ async function chatCompletion(config, messages, systemPrompt, model, tools) {
  * @param {object} emit Event-Helfer: { token(t), thinking(t), progress(icon, text), step(msg), done(obj), error(msg) }
  * @param {object} db Datenbankmodul
  */
-async function runResearchJob(config, session, userMessageText, emit, db) {
+async function runResearchJob(config, session, userMessageText, emit, db, signal) {
   let dashboardUrl = session.dashboard || null;
   let dashboardSaved = false;
+  let pendingDashboard = null;
+  // Sobald das Dashboard vorbereitet ist, läuft die nächste Runde mit minimalem
+  // Denken – das Budget gehört dann dem kompletten HTML (siehe deliveryEffort).
+  let deliveryEffort = null;
 
   const model = getModel(session.model || config.model);
   const toolDefs = model.vision ? [...TOOL_DEFINITIONS, SCREENSHOT_TOOL] : TOOL_DEFINITIONS;
   const prices = model.prices;
+  const isAborted = () => signal?.aborted === true;
 
   const handlers = {
     async search({ query }) {
@@ -392,7 +458,7 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
     },
     async browse({ url }) {
       emit.progress('🌐', `Besuche: ${url}`);
-      const result = await tools.browse(url, (m) => emit.step(m));
+      const result = await tools.browse(url, (m) => emit.step(m), { sessionId: session.id });
       return JSON.stringify(result);
     },
     async screenshot({ url, full_page }) {
@@ -405,6 +471,8 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
       return JSON.stringify(result);
     },
     async save_dashboard({ title, filename, html }) {
+      if (html && String(html).trim()) {
+        // Alter Weg: HTML direkt im Tool-Aufruf (nur kleine Dashboards)
         emit.progress('📊', 'Dashboard wird gespeichert…');
         const saved = tools.saveDashboard(session.id, filename || title, html, (m) => emit.step(m));
         dashboardUrl = saved.url;
@@ -412,6 +480,18 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
         db.setSessionDashboard(session.id, saved.url);
         emit.progress('📊', `Dashboard gespeichert: ${saved.file}`);
         return JSON.stringify(saved);
+      }
+      // Neuer Weg: nur vorbereiten, HTML kommt in der finalen Antwort
+      pendingDashboard = { title: title || 'Dashboard', filename: filename || null };
+      deliveryEffort = model.deliveryEffort || 'none';
+      emit.progress(
+        '📊',
+        `Dashboard vorbereitet (${(filename || title || 'dashboard').toLowerCase().replace(/[^a-z0-9äöü-]+/g, '-')}.html) – sende jetzt das komplette HTML in deiner finalen Antwort als \`\`\`html\`\`\`-Codeblock…`
+      );
+      return JSON.stringify({
+        ok: true,
+        note: 'Dashboard vorbereitet. Sende jetzt das komplette HTML in deiner finalen Antwort in einem ```html```-Codeblock. Kein weiterer Tool-Aufruf nötig.',
+      });
     },
     async geocode({ query }) {
       emit.progress('📍', `Geocode: ${query}`);
@@ -428,6 +508,7 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
   const apiMessages = db.toApiMessages(session.id, { provider: model.provider, vision: model.vision });
   const text = userMessageText;
   const usage = { promptTokens: 0, completionTokens: 0, cacheHitTokens: 0, cacheMissTokens: 0 };
+  let emptyRetries = 0;
   emit.progress('🤖', `Research startet mit ${model.label}…`);
 
   const trackUsage = (u) => {
@@ -450,9 +531,25 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
     return { text: finalText, dashboardUrl, usage, costEstimate, model: model.id };
   };
 
+  const finishAborted = () => {
+    db.createMessage(session.id, { role: 'assistant', content: '⛔ Recherche abgebrochen.' });
+    db.setSessionUsage(session.id, usage, prices);
+    db.setSessionStatus(session.id, 'done');
+    const costEstimate = db.computeCost(usage, prices);
+    emit.aborted?.();
+    return { text: '⛔ Recherche abgebrochen.', dashboardUrl, usage, costEstimate, model: model.id, aborted: true };
+  };
+
   for (let iter = 0; iter < MAX_ITERATIONS; iter++) {
+    if (isAborted()) return finishAborted();
     emit.progress('🤖', iter === 0 ? 'Analysiere Anfrage und plane Suche…' : 'Weitere Analyse…');
-    const result = await chatCompletion(config, apiMessages, buildSystemPrompt(session, model), model, toolDefs);
+    let result;
+    try {
+      result = await chatCompletion(config, apiMessages, buildSystemPrompt(session, model), model, toolDefs, signal, deliveryEffort);
+    } catch (e) {
+      if (isAborted() || e instanceof JobAbortedError) return finishAborted();
+      throw e;
+    }
     trackUsage(result.usage);
 
     if (result.reasoning) emit.thinking(result.reasoning);
@@ -511,10 +608,59 @@ async function runResearchJob(config, session, userMessageText, emit, db) {
           apiMessages.push({ role: 'tool', tool_call_id: tc.id, content: outStr.slice(0, 8000) });
         }
       }
+      if (isAborted()) return finishAborted();
       continue;
     }
 
-    const finalText = result.content || (dashboardUrl ? 'Recherche abgeschlossen – siehe Dashboard.' : '');
+    // Leere Antwort: Modell-Glitch oder abgebrochener Stream
+    if (!result.content) {
+      if (!pendingDashboard && !dashboardUrl && emptyRetries < MAX_EMPTY_RETRIES) {
+        emptyRetries++;
+        emit.progress('🔄', 'Leere Antwort erhalten – versuche es erneut…');
+        continue;
+      }
+      if (pendingDashboard) {
+        throw new Error(
+          `Modell ${model.id} hat das Dashboard-HTML nicht geliefert (leere Antwort). Bitte erneut versuchen.`
+        );
+      }
+      if (!dashboardUrl) {
+        const hint = result.reasoning
+          ? ` Letzter Gedanke: „${String(result.reasoning).slice(-200)}“`
+          : '';
+        throw new Error(
+          `Modell ${model.id} hat keine Antwort geliefert.${hint} Bitte erneut versuchen oder ein anderes Modell wählen.`
+        );
+      }
+    }
+
+    // Dashboard vorbereitet → HTML aus der finalen Antwort extrahieren und speichern
+    if (pendingDashboard && result.content) {
+      const html = extractHtmlBlock(result.content);
+      if (!html) {
+        if (/```html/i.test(result.content)) {
+          throw new Error(
+            `Modell ${model.id}: Dashboard-HTML unvollständig (Codeblock nicht geschlossen) – möglicherweise wurde das Token-Limit erreicht. Bitte erneut versuchen oder ein kleineres Dashboard anfragen.`
+          );
+        }
+        throw new Error(
+          `Modell ${model.id} hat das Dashboard-HTML nicht geliefert (kein \`\`\`html\`\`\`-Codeblock in der Antwort). Bitte erneut versuchen.`
+        );
+      }
+      const saved = tools.saveDashboard(
+        session.id,
+        pendingDashboard.filename || pendingDashboard.title,
+        html,
+        (m) => emit.step(m)
+      );
+      dashboardUrl = saved.url;
+      dashboardSaved = true;
+      db.setSessionDashboard(session.id, saved.url);
+      emit.progress('📊', `Dashboard gespeichert: ${saved.file}`);
+      result.content = stripHtmlBlock(result.content).trim() || `Fertig! Dein Dashboard ist online: ${saved.url}`;
+    }
+
+    const finalText = result.content || (dashboardUrl ? 'Recherche abgeschlossen – siehe Dashboard.' : 'Recherche abgeschlossen.');
     if (!dashboardSaved && dashboardUrl && isChangeRequest(userMessageText)) {
       emit.progress(
         '⚠️',

lib/tools.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const fs = require('fs');
+const crypto = require('crypto');
 const { chromium } = require('playwright');
 
 const DASHBOARD_DIR = path.join(__dirname, '..', 'dashboards');
@@ -92,8 +93,76 @@ async function search(query, log) {
   return results;
 }
 
-/** Seite besuchen und lesbaren Text extrahieren. */
+const IMAGE_TYPES = { 'image/jpeg': 'jpg', 'image/png': 'png', 'image/webp': 'webp', 'image/gif': 'gif' };
-async function browse(url, log) {
+const MAX_IMAGE_BYTES = 4 * 1024 * 1024;
+const MAX_TOTAL_IMAGE_BYTES = 12 * 1024 * 1024;
+const MAX_IMAGES = 8;
+
+/**
+ * Extrahiert Produktbild-URLs (nur absolute http(s), ausreichend groß, dedupliziert).
+ * Läuft im Browser-Kontext der besuchten Seite.
+ */
+function collectImages() {
+  const images = [];
+  const seen = new Set();
+  for (const img of document.querySelectorAll('img')) {
+    const src = (img.currentSrc || img.src || '').split('#')[0];
+    if (!/^https?:/i.test(src) || seen.has(src)) continue;
+    const nw = img.naturalWidth || 0;
+    const nh = img.naturalHeight || 0;
+    const rect = img.getBoundingClientRect();
+    const w = nw || rect.width || img.width || 0;
+    const h = nh || rect.height || img.height || 0;
+    if (w < 120 || h < 120) continue;
+    seen.add(src);
+    images.push({ url: src, alt: (img.alt || '').trim().slice(0, 120) });
+    if (images.length >= 12) break;
+  }
+  return images;
+}
+
+/**
+ * Lädt extrahierte Bilder lokal in den Dashboards-Ordner, damit das Dashboard
+ * sie unabhängig von Hotlink-Schutz und ablaufenden CDN-URLs einbetten kann.
+ * Dateiname: <sessionId>-img-<hash>.<ext> – wird beim Session-Löschen mit entfernt.
+ */
+async function cacheImages(page, images, sessionId, log) {
+  if (!sessionId) return images;
+  fs.mkdirSync(DASHBOARD_DIR, { recursive: true });
+  const existingFiles = new Set(fs.readdirSync(DASHBOARD_DIR));
+  const out = [];
+  let total = 0;
+  for (const img of images) {
+    if (out.length >= MAX_IMAGES || total >= MAX_TOTAL_IMAGE_BYTES) break;
+    try {
+      const hash = crypto.createHash('sha1').update(img.url).digest('hex').slice(0, 12);
+      const known = [...existingFiles].find((f) => f.startsWith(`${sessionId}-img-${hash}.`));
+      if (known) {
+        out.push({ url: `/dashboards/${known}`, alt: img.alt });
+        continue;
+      }
+      const resp = await page.request.get(img.url, {
+        timeout: 15000,
+        headers: { Referer: page.url() },
+      });
+      const type = String(resp.headers()['content-type'] || '').split(';')[0].trim().toLowerCase();
+      const ext = IMAGE_TYPES[type];
+      if (!ext || !resp.ok()) continue;
+      const buf = await resp.body();
+      if (buf.length < 512 || buf.length > MAX_IMAGE_BYTES || total + buf.length > MAX_TOTAL_IMAGE_BYTES) continue;
+      const file = `${sessionId}-img-${hash}.${ext}`;
+      fs.writeFileSync(path.join(DASHBOARD_DIR, file), buf);
+      existingFiles.add(file);
+      total += buf.length;
+      out.push({ url: `/dashboards/${file}`, alt: img.alt });
+    } catch {}
+  }
+  log?.(`Produktbilder lokal gespeichert: ${out.length}`);
+  return out;
+}
+
+/** Seite besuchen und lesbaren Text + Produktbilder (lokal gespeichert) extrahieren. */
+async function browse(url, log, opts = {}) {
   return withPage(url, async (page) => {
     const nav = await goto(page, url);
     if (!nav.ok) return { nav, error: 'Seite konnte nicht geladen werden' };
@@ -101,10 +170,12 @@ async function browse(url, log) {
     const data = await page.evaluate(() => {
       const title = document.title || '';
       const text = (document.body ? document.body.innerText : '').replace(/\s+\n/g, '\n');
-      return { title, text: text.slice(0, 15000) };
+      return { title, text: text.slice(0, 6000) };
     });
-    log?.(`Besuche ${url} -> ${data.title}`);
+    const extracted = await page.evaluate(collectImages);
-    return { nav, title: data.title, text: data.text };
+    const images = await cacheImages(page, extracted, opts.sessionId, log);
+    log?.(`Besuche ${url} -> ${data.title} (${images.length} Bilder lokal)`);
+    return { nav, title: data.title, images, text: data.text };
   });
 }
 
@@ -144,6 +215,23 @@ function saveDashboard(sessionId, filename, html, log) {
   return { file, url: `/dashboards/${file}` };
 }
 
+/** Alle Dashboard-Dateien einer Session (HTML/GPX/tour.json) löschen. */
+function deleteSessionFiles(sessionId) {
+  let entries;
+  try {
+    entries = fs.readdirSync(DASHBOARD_DIR);
+  } catch {
+    return;
+  }
+  for (const f of entries) {
+    if (f.startsWith(`${sessionId}-`)) {
+      try {
+        fs.unlinkSync(path.join(DASHBOARD_DIR, f));
+      } catch {}
+    }
+  }
+}
+
 /** Screenshot einer Seite (JPEG, als Data-URL) – für Vision-Modelle. */
 async function screenshot(url, fullPage = false, log) {
   return withPage(url, async (page) => {
@@ -374,4 +462,4 @@ async function closeBrowser() {
   }
 }
 
-module.exports = { search, browse, verify, saveDashboard, screenshot, geocode, saveTour, closeBrowser };
+module.exports = { search, browse, verify, saveDashboard, screenshot, geocode, saveTour, deleteSessionFiles, closeBrowser };

public/app.js

@@ -62,18 +62,52 @@ function renderSessions() {
         : s.status === 'done'
           ? '<span class="w-2 h-2 rounded-full bg-emerald-400 inline-block mr-2"></span>'
           : '<span class="w-2 h-2 rounded-full bg-slate-500 inline-block mr-2"></span>';
+    const row = document.createElement('div');
+    row.className = 'group relative';
     const btn = document.createElement('button');
     btn.className = `w-full text-left px-3 py-2 rounded-lg text-sm flex items-start gap-1 ${
       active ? 'bg-blue-600/20 text-blue-300' : 'hover:bg-slate-800'
     }`;
-    btn.innerHTML = `${dot}<span class="truncate">${escapeHtml(s.title)}</span>`;
+    btn.innerHTML = `${dot}<span class="truncate flex-1">${escapeHtml(s.title)}</span>`;
     btn.onclick = () => openSession(s.id);
-    list.appendChild(btn);
+    const del = document.createElement('button');
+    del.className =
+      'absolute right-1 top-1/2 -translate-y-1/2 w-6 h-6 rounded text-xs text-slate-500 hover:text-red-400 hover:bg-slate-700 opacity-0 group-hover:opacity-100';
+    del.textContent = '🗑';
+    del.title = 'Chat löschen';
+    del.onclick = (e) => {
+      e.stopPropagation();
+      deleteSession(s.id);
+    };
+    row.append(btn, del);
+    list.appendChild(row);
   }
   const qs = state.sessions.find((s) => s.job === 'running' || s.job === 'queued');
   $('queueStatus').classList.toggle('hidden', !qs);
 }
 
+async function deleteSession(id) {
+  const s = state.sessions.find((x) => x.id === id);
+  if (!confirm(`Chat „${s?.title || '…'}“ wirklich löschen? Das zugehörige Dashboard wird mit gelöscht.`)) return;
+  const res = await fetch(`/api/sessions/${id}`, { method: 'DELETE' });
+  if (!res.ok) {
+    addToolLine('⚠️', 'Löschen fehlgeschlagen');
+    return;
+  }
+  if (state.current?.id === id) {
+    state.stream?.close();
+    state.stream = null;
+    state.streamingEl = null;
+    state.current = null;
+    hideActivity();
+    const next = state.sessions.find((x) => x.id !== id);
+    if (next) await openSession(next.id);
+    else await newSession();
+  } else {
+    await loadSessions();
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Chat-Rendering
 // ---------------------------------------------------------------------------
@@ -187,6 +221,8 @@ function showActivity() {
   $('activityLog').classList.add('hidden');
   $('toggleLog').textContent = 'Details zeigen';
   state.activityShown = true;
+  $('abortBtn').classList.remove('hidden');
+  $('abortBtn').disabled = false;
 }
 
 function setActivity(text, icon = '') {
@@ -202,15 +238,29 @@ function logActivity(text) {
 
 function hideActivity() {
   $('activityBar').classList.add('hidden');
+  $('abortBtn').classList.add('hidden');
   state.activityShown = false;
 }
 
+async function abortResearch() {
+  if (!state.current) return;
+  $('abortBtn').disabled = true;
+  setActivity('Breche Recherche ab…', '⛔');
+  try {
+    await fetch(`/api/sessions/${state.current.id}/abort`, { method: 'POST' });
+  } catch {
+    $('abortBtn').disabled = false;
+  }
+}
+
 $('toggleLog').onclick = () => {
   const log = $('activityLog');
   const hidden = log.classList.toggle('hidden');
   $('toggleLog').textContent = hidden ? 'Details zeigen' : 'Details verbergen';
 };
 
+$('abortBtn').onclick = abortResearch;
+
 // ---------------------------------------------------------------------------
 // SSE-Stream
 // ---------------------------------------------------------------------------
@@ -286,6 +336,13 @@ function connectStream(sessionId) {
     $('sendBtn').disabled = false;
   });
 
+  es.addEventListener('aborted', () => {
+    addToolLine('⛔', 'Recherche abgebrochen.');
+    hideActivity();
+    loadSessions();
+    $('sendBtn').disabled = false;
+  });
+
   es.addEventListener('error', (e) => {
     if (!e.data) return;
     const d = JSON.parse(e.data);

public/index.html

@@ -57,6 +57,8 @@
       <div id="activityLine" class="flex items-center gap-2">
         <span class="inline-block w-3 h-3 border-2 border-blue-500 border-t-transparent rounded-full animate-spin"></span>
         <span id="activityText">Starte…</span>
+        <button id="abortBtn" type="button" title="Recherche abbrechen"
+                class="ml-auto hidden text-xs px-2 py-1 rounded-lg bg-red-600/15 text-red-400 hover:bg-red-600/30">⛔ Abbrechen</button>
       </div>
       <div id="activityLog" class="hidden mt-1 max-h-32 overflow-y-auto text-xs text-slate-400 space-y-0.5"></div>
       <button id="toggleLog" class="text-xs text-blue-400 mt-1">Details zeigen</button>

public/share.html

@@ -28,7 +28,7 @@
     <div id="content" class="hidden space-y-4"></div>
 
     <footer class="mt-8 text-center text-xs text-slate-500">
-      <p>Generiert mit dem Research Agent · DeepSeek V4 Flash / GLM 5.3 Flash</p>
+      <p>Generiert mit dem Research Agent · DeepSeek V4.1 Flash</p>
     </footer>
   </div>
 

server.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const http = require('http');
 const crypto = require('crypto');
+const fs = require('fs');
 const express = require('express');
 const webpush = require('web-push');
 
@@ -8,7 +9,7 @@ const { config, getModel, getModels } = require('./lib/config');
 const db = require('./lib/db');
 const queue = require('./lib/queue');
 const { runResearchJob } = require('./lib/research');
-const { closeBrowser } = require('./lib/tools');
+const { closeBrowser, deleteSessionFiles } = require('./lib/tools');
 
 const app = express();
 app.disable('x-powered-by');
@@ -165,7 +166,7 @@ app.post('/api/sessions', requireAuth, (req, res) => {
 
 app.patch('/api/sessions/:id', requireAuth, (req, res) => {
   const session = db.getSession(req.params.id);
-  if (!session || session.owner_name !== req.user.n) {
+  if (!session) {
     return res.status(404).json({ error: 'Session nicht gefunden' });
   }
   const modelId = String(req.body?.model || '');
@@ -206,9 +207,35 @@ app.get('/api/sessions/:id/share', requireAuth, (req, res) => {
 
 app.delete('/api/sessions/:id', requireAuth, (req, res) => {
   const session = db.getSession(req.params.id);
-  if (!session) return res.status(404).json({ error: 'Session nicht gefunden' });
+  if (!session) {
+    return res.status(404).json({ error: 'Session nicht gefunden' });
+  }
   queue.cancelQueued(session.id);
+  queue.abortRunning(session.id);
   db.deleteSession(session.id);
+  deleteSessionFiles(session.id);
+  res.json({ ok: true });
+});
+
+app.post('/api/sessions/:id/abort', requireAuth, (req, res) => {
+  const session = db.getSession(req.params.id);
+  if (!session) {
+    return res.status(404).json({ error: 'Session nicht gefunden' });
+  }
+  if (queue.queuedBefore(session.id) >= 0) {
+    // Job wartet noch in der Queue → direkt entfernen und aufräumen
+    queue.cancelQueued(session.id);
+  } else if (queue.hasController(session.id)) {
+    // Laufender Job → Controller auslösen, der Job räumt selbst auf
+    queue.abortRunning(session.id);
+    return res.json({ ok: true });
+  }
+  // Wartender Job oder veralteter Job (z.B. nach Server-Neustart, ohne
+  // laufenden Prozess): Zustand und UI direkt zurücksetzen
+  db.createMessage(session.id, { role: 'assistant', content: '⛔ Recherche abgebrochen.' });
+  db.setSessionStatus(session.id, 'done');
+  emitToSession(session.id, 'aborted', {});
+  emitToSession(session.id, 'status', { sessionStatus: 'done', jobStatus: 'aborted' });
   res.json({ ok: true });
 });
 
@@ -242,7 +269,7 @@ app.post('/api/sessions/:id/messages', requireAuth, (req, res) => {
     const model = getModel(session.model);
     if (!model.vision) {
       return res.status(400).json({
-        error: `Das Modell "${model.label}" kann keine Bilder verarbeiten – bitte auf ein Modell mit Bilderkennung wechseln (z.B. GLM 5.3 Flash).`,
+        error: `Das Modell "${model.label}" kann keine Bilder verarbeiten.`,
       });
     }
   }
@@ -259,9 +286,12 @@ app.post('/api/sessions/:id/messages', requireAuth, (req, res) => {
   }
   db.setSessionStatus(session.id, 'queued');
 
+  const controller = queue.registerController(session.id);
+
   const job = {
     sessionId: session.id,
     async run() {
+      try {
         db.setSessionStatus(session.id, 'running');
         emitToSession(session.id, 'status', { sessionStatus: 'running', jobStatus: 'running' });
 
@@ -275,6 +305,10 @@ app.post('/api/sessions/:id/messages', requireAuth, (req, res) => {
             emitToSession(session.id, 'status', { sessionStatus: 'done', jobStatus: 'done' });
             sendPush(session, result);
           },
+          aborted: () => {
+            emitToSession(session.id, 'aborted', {});
+            emitToSession(session.id, 'status', { sessionStatus: 'done', jobStatus: 'aborted' });
+          },
           error: (msg) => emitToSession(session.id, 'error', { text: msg }),
         };
 
@@ -283,8 +317,12 @@ app.post('/api/sessions/:id/messages', requireAuth, (req, res) => {
           db.getSession(session.id),
           text,
           emit,
-        db
+          db,
+          controller.signal
         );
+      } finally {
+        queue.clearController(session.id);
+      }
     },
     async onError(e) {
       console.error('Job-Fehler:', e);
@@ -379,6 +417,75 @@ function sendPush(session, result) {
 // Statische Dateien & Dashboard-Dateien
 // ---------------------------------------------------------------------------
 
+// Wird in jedes ausgelieferte Dashboard-HTML injiziert: speichert den Zustand
+// der Checklisten-Häkchen im localStorage und stellt ihn beim Laden wieder her
+// (inkl. „Liste zurücksetzen"-Button). Key = Label-Text der Checkbox, damit
+// der Stand auch bei Layout-Änderungen stabil bleibt.
+const CHECKLIST_SCRIPT = `<script>
+(function () {
+  var KEY = 'rc-checks:' + location.pathname;
+  var boxes = document.querySelectorAll('input[type=checkbox]');
+  if (!boxes.length) return;
+  var saved = {};
+  try { saved = JSON.parse(localStorage.getItem(KEY) || '{}'); } catch (e) {}
+
+  function labelFor(box, i) {
+    var li = box.closest('li');
+    var t = li ? li.querySelector('.check-text') : null;
+    var text = (t || li || {}).textContent || '';
+    return text.trim() || 'item-' + i;
+  }
+
+  boxes.forEach(function (box, i) {
+    var k = labelFor(box, i);
+    if (saved[k] !== undefined) box.checked = !!saved[k];
+    box.addEventListener('change', function () {
+      saved[k] = box.checked;
+      try { localStorage.setItem(KEY, JSON.stringify(saved)); } catch (e) {}
+    });
+  });
+
+  function refresh() {
+    if (typeof update === 'function') update();
+  }
+
+  // „Liste zurücksetzen"-Button am Anfang der ersten Checklisten-Section
+  var firstBox = boxes[0];
+  var section = firstBox.closest('section') || firstBox.closest('div') || document.body;
+  var btn = document.createElement('button');
+  btn.type = 'button';
+  btn.textContent = '↺ Liste zurücksetzen';
+  btn.style.cssText =
+    'margin:0 0 12px;padding:6px 14px;font-size:12px;font-weight:600;border-radius:8px;' +
+    'border:1px solid rgba(100,116,139,.4);background:transparent;color:inherit;cursor:pointer;';
+  btn.addEventListener('click', function () {
+    if (!confirm('Alle Häkchen dieser Liste zurücksetzen?')) return;
+    try { localStorage.removeItem(KEY); } catch (e) {}
+    saved = {};
+    boxes.forEach(function (b) { b.checked = false; });
+    refresh();
+  });
+  section.insertBefore(btn, section.firstChild);
+
+  refresh();
+})();
+</script>`;
+
+const CHECKLIST_MARKER = 'rc-checks';
+
+app.get('/dashboards/:name.html', (req, res, next) => {
+  const name = path.basename(req.params.name);
+  const file = path.join(__dirname, 'dashboards', `${name}.html`);
+  fs.readFile(file, 'utf8', (err, html) => {
+    if (err) return next();
+    if (!html.includes(CHECKLIST_MARKER)) {
+      html = html.replace(/<\/body>/i, `${CHECKLIST_SCRIPT}\n</body>`);
+    }
+    res.setHeader('Cache-Control', 'no-cache');
+    res.type('html').send(html);
+  });
+});
+
 app.use(
   '/dashboards',
   express.static(path.join(__dirname, 'dashboards'), {
@@ -412,12 +519,16 @@ app.get('/', (req, res) => {
 
 // ---------------------------------------------------------------------------
 
+// Nach einem Server-Neustart hängengebliebene Jobs (running/queued in der DB)
+// zurücksetzen – die Jobs existieren im Speicher nicht mehr.
+const staleCount = db.markStaleJobs();
+if (staleCount > 0) {
+  console.log(`INFO: ${staleCount} verwaiste Recherche(n) nach Neustart zurückgesetzt.`);
+}
+
 if (!config.apiKey) {
   console.error('WARNUNG: DEEPSEEK_API_KEY fehlt in .env – DeepSeek-Modelle werden nicht funktionieren.');
 }
-if (!config.openrouterApiKey) {
-  console.error('WARNUNG: OPENROUTER_API_KEY fehlt in .env – OpenRouter-Modelle (z.B. GLM 5.3 Flash) werden nicht funktionieren.');
-}
 if (!config.appPassword) {
   console.error('WARNUNG: APP_PASSWORD fehlt in .env – Login ohne Passwort-Check.');
 }