Leichte Sprache automatisch für Leser, mehrere KI-Anbieter

Statt eines KI-Knopfs in der Redaktion entsteht die Leichte Sprache jetzt
automatisch für Leser:
- Ist „Leichte Sprache“ eingeschaltet und gibt es keine eigene Fassung,
  wird der Text beim ersten Aufruf live übertragen, gespeichert und allen
  weiteren Lesern sofort gezeigt; nach Textänderungen neu (Prüfsumme)
- Beim Speichern einer Seite/Meldung wird im Hintergrund vorab übertragen
  (Warteschlange, eine Übertragung gleichzeitig)
- Gekennzeichnet als „automatisch übertragen“ mit „Fehler melden“;
  eigene Fassungen der Redaktion haben immer Vorrang
- Modell-Ausgabe wird nur bereinigt als HTML angezeigt (Live-Text nur als
  reiner Text) – getestet mit Schadcode aus dem Modell

Anbieter (Einstellungen): Anthropic (Claude, Anthropic-SDK), OpenAI,
DeepSeek, Ollama (OpenAI-kompatibel über das OpenAI-SDK); Modelle laden,
Verbindung testen, API-Schlüssel AES-256-GCM-verschlüsselt und nie wieder
angezeigt, Tageslimit, Sperre pro Gerät, Anrede du/Sie.
Datenschutz-Vorlage um den Abschnitt „Automatische Leichte Sprache“ ergänzt.

Seed: „heute“ liegt nicht mehr in der Zukunft (Meldung sonst unsichtbar).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Friederich Loheide 2026-10-03 05:49:18 +00:00
parent 8862a095c0
commit c20f3a73d0
34 changed files with 2527 additions and 329 deletions

View file

@ -16,9 +16,6 @@ SMTP_USER=
SMTP_PASS=
SMTP_FROM="Werkstatt-App <no-reply@example.org>"
# Leichte Sprache mit KI (Claude von Anthropic). Ohne Schlüssel ist der Knopf ausgeblendet.
ANTHROPIC_API_KEY=
# Push-Benachrichtigungen: Schlüssel werden beim ersten Start automatisch erzeugt und
# in der Datenbank gespeichert. Nur setzen, wenn eigene Schlüssel verwendet werden sollen
# (erzeugen mit: npx web-push generate-vapid-keys).

View file

@ -15,7 +15,8 @@ Tablet und Desktop.
- Termine & Schließzeiten, gruppiert nach Monat, mit Kalender-Abo (`/termine.ics`)
- Ansprechpartner-Verzeichnis, Kontaktformular, Volltextsuche
- **Barrierearm:** klare Schrift (Montserrat, selbst gehostet), 3 Schriftgrößen, Hell/Dunkel,
**Leichte Sprache** pro Seite/Meldung
**Leichte Sprache** pro Seite/Meldung – eigene geprüfte Fassung oder automatisch per KI übertragen
(live beim ersten Aufruf bzw. vorab beim Speichern, gekennzeichnet, mit „Fehler melden“)
- **Vorlesen** jeder Seite (Knopf in der Kopfzeile) oder eines Artikels: satzweise, der gelesene Satz
wird markiert und mitgescrollt, mit Pause, Satz vor/zurück und langsamem Tempo
- **Push-Benachrichtigungen** zu Neuigkeiten und Schließzeiten (Themen frei wählbar, jederzeit abbestellbar)
@ -34,9 +35,8 @@ Tablet und Desktop.
- Meldungen (Entwurf, geplante Veröffentlichung, anheften), Seitenbaum, Termine,
Startseiten-Bereiche, Mediathek, Postfach
- Text-Editor mit Formatierungen, Links und Bildern
- **Leichte Sprache per KI:** „Mit KI erstellen“ schreibt aus dem normalen Text einen Entwurf nach den
Regeln für Leichte Sprache (Claude Opus 5, live gestreamt, Anrede du/Sie einstellbar) – zum Prüfen
und Speichern
- **Leichte Sprache per KI** (Einstellungen): Anbieter Anthropic (Claude), OpenAI, DeepSeek oder Ollama,
Modell wählbar, Schlüssel verschlüsselt gespeichert, Verbindungstest, Tageslimit
- Bilder werden automatisch gedreht, verkleinert und als WebP gespeichert
- **Benachrichtigungen:** beim Erscheinen einer Meldung (auch zeitgesteuert), automatisch am Vortag einer
Schließzeit, oder von Hand – mit Vorschau und Verlauf
@ -91,7 +91,6 @@ Ohne Docker: `npm ci && npm run build && ORIGIN=https://… BODY_SIZE_LIMIT=30M
| `ADMIN_EMAIL` / `ADMIN_PASSWORD` | Erster Admin, wird angelegt, solange es noch keinen Benutzer gibt |
| `BODY_SIZE_LIMIT` | Max. Upload-Größe (im Docker-Image auf 30M gesetzt) |
| `SMTP_HOST`, `SMTP_PORT`, `SMTP_USER`, `SMTP_PASS`, `SMTP_FROM` | E-Mail-Versand für „Passwort vergessen“. Ohne SMTP steht der Link im Server-Log |
| `ANTHROPIC_API_KEY` | Für „Leichte Sprache mit KI“ (Claude). Ohne Schlüssel ist die Funktion ausgeblendet |
| `VAPID_PUBLIC_KEY` / `VAPID_PRIVATE_KEY` | Optional – sonst werden die Push-Schlüssel automatisch erzeugt und gespeichert |
## Erweitern

View file

@ -8,7 +8,6 @@ services:
ORIGIN: ${ORIGIN:-http://localhost:3000}
ADMIN_EMAIL: ${ADMIN_EMAIL:-}
ADMIN_PASSWORD: ${ADMIN_PASSWORD:-}
ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
SMTP_HOST: ${SMTP_HOST:-}
SMTP_PORT: ${SMTP_PORT:-587}
SMTP_SECURE: ${SMTP_SECURE:-false}

View file

@ -0,0 +1,8 @@
ALTER TABLE `pages` ADD `content_easy_auto` text DEFAULT '' NOT NULL;--> statement-breakpoint
ALTER TABLE `pages` ADD `content_easy_auto_hash` text DEFAULT '' NOT NULL;--> statement-breakpoint
ALTER TABLE `pages` ADD `content_easy_auto_model` text DEFAULT '' NOT NULL;--> statement-breakpoint
ALTER TABLE `pages` ADD `content_easy_auto_at` integer;--> statement-breakpoint
ALTER TABLE `posts` ADD `content_easy_auto` text DEFAULT '' NOT NULL;--> statement-breakpoint
ALTER TABLE `posts` ADD `content_easy_auto_hash` text DEFAULT '' NOT NULL;--> statement-breakpoint
ALTER TABLE `posts` ADD `content_easy_auto_model` text DEFAULT '' NOT NULL;--> statement-breakpoint
ALTER TABLE `posts` ADD `content_easy_auto_at` integer;

File diff suppressed because it is too large Load diff

View file

@ -22,6 +22,13 @@
"when": 1790788599464,
"tag": "0002_sicherheit_push_recht",
"breakpoints": true
},
{
"idx": 3,
"version": "6",
"when": 1791006046542,
"tag": "0003_leichte_sprache_auto",
"breakpoints": true
}
]
}

38
package-lock.json generated
View file

@ -12,6 +12,7 @@
"better-sqlite3": "^13.0.3",
"drizzle-orm": "^0.45.3",
"nodemailer": "^10.0.13",
"openai": "^7.27.0",
"qrcode": "^1.5.4",
"sanitize-html": "^2.17.0",
"sharp": "^0.35.5",
@ -5088,6 +5089,43 @@
"node": ">=12.20.0"
}
},
"node_modules/openai": {
"version": "7.27.0",
"resolved": "https://registry.npmjs.org/openai/-/openai-7.27.0.tgz",
"integrity": "sha512-QDo1FvnRDZn15YwGVOhT9vpyypDiLphkd/7a4mcURWf5upMoEetgA6o4DJeII+ZZkC6m6DvlilCwii3+ynDcTw==",
"license": "Apache-2.0",
"engines": {
"node": ">=22.0.0"
},
"peerDependencies": {
"@aws-sdk/credential-provider-node": ">=3.972.0 <4",
"@smithy/hash-node": ">=4.3.0 <5",
"@smithy/signature-v4": ">=5.4.0 <6",
"undici": ">=5 <9",
"ws": "^8.21.0",
"zod": "^3.25 || ^4.0"
},
"peerDependenciesMeta": {
"@aws-sdk/credential-provider-node": {
"optional": true
},
"@smithy/hash-node": {
"optional": true
},
"@smithy/signature-v4": {
"optional": true
},
"undici": {
"optional": true
},
"ws": {
"optional": true
},
"zod": {
"optional": true
}
}
},
"node_modules/orderedmap": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/orderedmap/-/orderedmap-2.1.1.tgz",

View file

@ -22,6 +22,7 @@
"better-sqlite3": "^13.0.3",
"drizzle-orm": "^0.45.3",
"nodemailer": "^10.0.13",
"openai": "^7.27.0",
"qrcode": "^1.5.4",
"sanitize-html": "^2.17.0",
"sharp": "^0.35.5",

View file

@ -43,7 +43,8 @@ const daysAgo = (n: number, hour = 9) => {
const d = new Date();
d.setDate(d.getDate() - n);
d.setHours(hour, 0, 0, 0);
return d;
// „heute 9 Uhr“ darf nicht in der Zukunft liegen, sonst ist die Meldung noch unsichtbar
return d.getTime() > Date.now() ? new Date(Date.now() - 30 * 60e3) : d;
};
/** Erzeugt ein ruhiges Demo-Titelbild: Farbfläche mit großem Kreisausschnitt (keine echten Fotos in der Demo). */

View file

@ -0,0 +1,138 @@
<script lang="ts">
import { untrack } from 'svelte';
import Download from '@lucide/svelte/icons/download';
import PlugZap from '@lucide/svelte/icons/plug-zap';
import LoaderCircle from '@lucide/svelte/icons/loader-circle';
import Switch from './Switch.svelte';
import { AI_PROVIDERS, type AiProvider, type AppSettings } from '$lib/settings';
type Ai = { ready: boolean; keyHint: string; usedToday: number };
let { s, ai }: { s: AppSettings; ai: Ai } = $props();
let provider = $state<AiProvider>(untrack(() => s.aiProvider));
let model = $state(untrack(() => s.aiModel));
let baseUrl = $state(untrack(() => s.aiBaseUrl));
let apiKey = $state('');
let models = $state<string[]>([]);
let busy = $state<'' | 'models' | 'test'>('');
let result = $state<{ ok: boolean; text: string } | null>(null);
const p = $derived(AI_PROVIDERS[provider]);
async function call(path: string) {
const res = await fetch(path, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ provider, model, baseUrl, apiKey })
});
const data = await res.json().catch(() => ({}));
if (!res.ok) throw new Error(data.message ?? 'Fehler');
return data;
}
async function loadModels() {
busy = 'models';
result = null;
try {
models = (await call('/admin/api/ki/modelle')).models;
result = { ok: true, text: `${models.length} Modelle gefunden – im Feld „Modell“ auswählen.` };
} catch (e) {
result = { ok: false, text: (e as Error).message };
} finally {
busy = '';
}
}
async function test() {
busy = 'test';
result = null;
try {
const r = await call('/admin/api/ki/test');
result = { ok: true, text: `Funktioniert (${(r.ms / 1000).toFixed(1).replace('.', ',')} s): „${r.text}“` };
} catch (e) {
result = { ok: false, text: (e as Error).message };
} finally {
busy = '';
}
}
</script>
<div class="space-y-5">
<Switch
name="aiEnabled"
checked={s.aiEnabled}
label="Automatische Leichte Sprache einschalten"
hint="Texte ohne eigene Fassung werden für Leser automatisch übertragen und gekennzeichnet."
/>
<div class="grid sm:grid-cols-2 gap-4">
<div>
<label class="label" for="aiProvider">Anbieter</label>
<select id="aiProvider" name="aiProvider" class="field" bind:value={provider} onchange={() => ((models = []), (result = null))}>
{#each Object.entries(AI_PROVIDERS) as [key, def] (key)}<option value={key}>{def.label}</option>{/each}
</select>
</div>
<div>
<label class="label" for="aiModel">Modell</label>
<div class="flex gap-2">
<input id="aiModel" name="aiModel" class="field" list="ai-models" bind:value={model} placeholder={p.defaultModel || 'Modell wählen'} autocomplete="off" />
<button type="button" class="btn btn-soft btn-icon shrink-0" aria-label="Modelle beim Anbieter laden" title="Modelle laden" disabled={!!busy} onclick={loadModels}>
{#if busy === 'models'}<LoaderCircle class="size-4 animate-spin" />{:else}<Download class="size-4" />{/if}
</button>
</div>
<datalist id="ai-models">{#each models as m (m)}<option value={m}></option>{/each}</datalist>
{#if p.defaultModel}<p class="hint">Leer = {p.defaultModel}</p>{/if}
</div>
<div class="sm:col-span-2">
<label class="label" for="aiBaseUrl">Adresse {provider === 'ollama' ? '' : '(optional)'}</label>
<input id="aiBaseUrl" name="aiBaseUrl" class="field" bind:value={baseUrl} placeholder={p.defaultBaseUrl || 'Standard des Anbieters'} />
<p class="hint">
{#if provider === 'ollama'}
Adresse eures Ollama-Servers mit <code>/v1</code> am Ende, z. B. <code>http://ki.intern:11434/v1</code>. Die Texte verlassen dann euer Netz nicht.
{:else}
Nur nötig für einen eigenen Endpunkt oder Proxy.
{/if}
</p>
</div>
{#if p.needsKey}
<div class="sm:col-span-2">
<label class="label" for="aiKey">API-Schlüssel</label>
<input id="aiKey" name="aiKey" type="password" class="field" bind:value={apiKey} autocomplete="off" placeholder={ai.keyHint ? `gespeichert (${ai.keyHint}) – leer lassen zum Behalten` : 'Schlüssel einfügen'} />
<p class="hint">Wird verschlüsselt gespeichert und nie wieder angezeigt.</p>
{#if ai.keyHint}
<label class="inline-flex items-center gap-2 text-sm mt-2 cursor-pointer"><input type="checkbox" name="aiKeyDelete" class="accent-[var(--brand)]" />Gespeicherten Schlüssel löschen</label>
{/if}
</div>
{/if}
</div>
<div class="flex flex-wrap items-center gap-3">
<button type="button" class="btn btn-soft" disabled={!!busy} onclick={test}>
{#if busy === 'test'}<LoaderCircle class="size-4 animate-spin" />{:else}<PlugZap class="size-4" />{/if}
Verbindung testen
</button>
<span class="text-sm text-ink-3">Testet die Angaben oben, auch ungespeichert.</span>
</div>
{#if result}
<p class="text-sm rounded-xl px-4 py-3 {result.ok ? 'bg-surface-2' : 'bg-danger/10 text-danger font-semibold'}" role={result.ok ? 'status' : 'alert'}>{result.text}</p>
{/if}
<div class="grid sm:grid-cols-2 gap-4">
<fieldset>
<legend class="label">Anrede</legend>
<div class="flex gap-4">
{#each ['du', 'Sie'] as a (a)}
<label class="inline-flex items-center gap-2 cursor-pointer min-h-8"><input type="radio" name="easyAddress" value={a} checked={s.easyAddress === a} class="accent-[var(--brand)]" />„{a}“</label>
{/each}
</div>
</fieldset>
<div>
<label class="label" for="aiDailyLimit">Höchstens Übertragungen pro Tag</label>
<input id="aiDailyLimit" name="aiDailyLimit" type="number" min="0" max="5000" class="field" value={s.aiDailyLimit} />
<p class="hint">Heute verwendet: {ai.usedToday}. Schützt vor unerwarteten Kosten.</p>
</div>
</div>
<p class="text-sm text-ink-2">
Status: {#if ai.ready}<strong>eingerichtet und aktiv</strong>{:else}<strong>nicht aktiv</strong> – einschalten, Modell wählen{p.needsKey ? ' und Schlüssel eintragen' : ''}, dann speichern.{/if}
</p>
</div>

View file

@ -1,141 +1,63 @@
<script lang="ts">
import { untrack } from 'svelte';
import { page } from '$app/state';
import BookHeart from '@lucide/svelte/icons/book-heart';
import ChevronDown from '@lucide/svelte/icons/chevron-down';
import Sparkles from '@lucide/svelte/icons/sparkles';
import Square from '@lucide/svelte/icons/square';
import LoaderCircle from '@lucide/svelte/icons/loader-circle';
import RichEditor from './RichEditor.svelte';
import { toasts } from './toast.svelte';
import { STREAM_ERROR } from '$lib/easy-language';
let { value = '' }: { value?: string } = $props();
type Auto = { enabled: boolean; html: string; fresh: boolean; at: string | null; model: string } | null;
let { value = '', auto = null }: { value?: string; auto?: Auto } = $props();
let open = $state(untrack(() => !!value));
let showAuto = $state(false);
let editor = $state<ReturnType<typeof RichEditor>>();
let root: HTMLElement;
let busy = $state(false);
let preview = $state('');
let confirmOverwrite = $state(false);
let aiDraft = $state(false);
let controller: AbortController | null = null;
const words = $derived(preview.replace(/<[^>]+>/g, ' ').trim().split(/\s+/).filter(Boolean).length);
const previewText = $derived(
preview
.replace(/<[^>]*$/, '') // halb übertragenes Tag am Ende
.replace(/<\/(p|h2|h3|li)>/g, '\n')
.replace(/<li>/g, '• ')
.replace(/<[^>]+>/g, '')
.replace(/\n{2,}/g, '\n')
.trim()
);
/** Liest Titel und Text aus dem umgebenden Formular – auch noch nicht gespeicherte Änderungen */
function source() {
const form = root.closest('form');
const data = form ? new FormData(form) : new FormData();
return { title: String(data.get('title') ?? ''), html: String(data.get('content') ?? '') };
}
async function generate() {
const { title, html } = source();
if (!html.replace(/<[^>]+>/g, '').trim()) {
toasts.show('Bitte zuerst oben den normalen Text schreiben.', 'error');
return;
}
if (editor?.getHtml() && !confirmOverwrite) {
confirmOverwrite = true;
return;
}
confirmOverwrite = false;
open = true;
busy = true;
preview = '';
controller = new AbortController();
try {
const res = await fetch('/admin/api/leichte-sprache', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ title, html }),
signal: controller.signal
});
if (!res.ok || !res.body) {
toasts.show((await res.json().catch(() => null))?.message ?? 'Die KI ist gerade nicht erreichbar.', 'error');
return;
}
const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
for (;;) {
const { value: chunk, done } = await reader.read();
if (done) break;
preview += chunk;
}
const errorAt = preview.indexOf(STREAM_ERROR);
if (errorAt >= 0) {
toasts.show(preview.slice(errorAt + STREAM_ERROR.length), 'error');
return;
}
// Falls die KI doch einen Code-Block drumherum schreibt
const clean = preview.replace(/^```(?:html)?\s*/i, '').replace(/```\s*$/, '').trim();
editor?.setContent(clean);
aiDraft = true;
toasts.show('Entwurf in Leichter Sprache eingefügt – bitte prüfen und speichern');
} catch (e) {
if ((e as Error).name !== 'AbortError') toasts.show('Die Verbindung zur KI ist abgebrochen.', 'error');
} finally {
busy = false;
controller = null;
preview = '';
}
}
const when = (iso: string) => new Date(iso).toLocaleString('de-DE', { dateStyle: 'short', timeStyle: 'short' });
</script>
<section class="card overflow-hidden" bind:this={root}>
<div class="flex flex-wrap items-center gap-3 p-5">
<button type="button" class="flex flex-1 min-w-60 items-center gap-3 text-left" onclick={() => (open = !open)} aria-expanded={open}>
<span class="grid place-items-center size-10 rounded-full bg-surface-2 text-brand-ink shrink-0" aria-hidden="true"><BookHeart class="size-5" /></span>
<span class="flex-1">
<span class="block text-lg font-bold">Leichte Sprache</span>
<span class="block text-sm text-ink-3">Optional: eine einfache Fassung des Textes. Wird angezeigt, wenn Leser „Leichte Sprache“ einschalten.</span>
<section class="card overflow-hidden">
<button type="button" class="w-full flex items-center gap-3 p-5 text-left" onclick={() => (open = !open)} aria-expanded={open}>
<span class="grid place-items-center size-10 rounded-full bg-surface-2 text-brand-ink shrink-0" aria-hidden="true"><BookHeart class="size-5" /></span>
<span class="flex-1">
<span class="block text-lg font-bold">Leichte Sprache</span>
<span class="block text-sm text-ink-3">
{auto?.enabled
? 'Optional: eigene, geprüfte Fassung. Ohne sie zeigt die App automatisch eine KI-Übertragung.'
: 'Optional: eine einfache Fassung des Textes. Wird angezeigt, wenn Leser „Leichte Sprache“ einschalten.'}
</span>
<ChevronDown class="size-5 text-ink-3 transition-transform {open ? 'rotate-180' : ''}" />
</button>
{#if page.data.aiEasy}
{#if busy}
<button type="button" class="btn btn-soft btn-sm" onclick={() => controller?.abort()}><Square class="size-3.5" fill="currentColor" />Abbrechen</button>
{:else}
<button type="button" class="btn btn-accent btn-sm" onclick={generate} aria-describedby="ki-hinweis">
<Sparkles class="size-4" />{confirmOverwrite ? 'Vorhandenen Text ersetzen?' : 'Mit KI erstellen'}
</button>
{/if}
{/if}
</div>
</span>
<ChevronDown class="size-5 text-ink-3 transition-transform {open ? 'rotate-180' : ''}" />
</button>
<div class="px-5 pb-5 space-y-3" hidden={!open}>
{#if busy}
<div class="rounded-2xl border-2 border-dashed border-accent/50 bg-accent-soft/30 p-4" aria-live="polite" aria-busy="true">
<p class="flex items-center gap-2 text-sm font-semibold text-accent-ink">
<LoaderCircle class="size-4 animate-spin" />
{words ? `KI schreibt … ${words} Wörter` : 'KI liest den Text …'}
{#if auto?.enabled && !value}
<div class="rounded-xl bg-surface-2 px-4 py-3 text-sm space-y-2" role="status">
<p class="flex items-start gap-2">
<Sparkles class="size-4 mt-0.5 shrink-0 text-accent" aria-hidden="true" />
<span>
{#if auto.html && auto.fresh}
Automatische Fassung vorhanden – erstellt am {when(auto.at!)} mit {auto.model}.
{:else if auto.html}
Der Text wurde geändert. Die automatische Fassung wird beim Speichern bzw. beim nächsten Aufruf neu erstellt.
{:else}
Noch keine automatische Fassung. Sie wird nach dem Speichern im Hintergrund erstellt.
{/if}
</span>
</p>
{#if previewText}<p class="mt-2 text-sm whitespace-pre-line text-ink-2 max-h-60 overflow-y-auto">{previewText}</p>{/if}
{#if auto.html}
<button type="button" class="text-sm font-semibold text-brand-ink underline underline-offset-2 min-h-6" aria-expanded={showAuto} onclick={() => (showAuto = !showAuto)}>
{showAuto ? 'Automatische Fassung ausblenden' : 'Automatische Fassung ansehen'}
</button>
{#if showAuto}
<div class="rich !text-base rounded-lg bg-surface p-4 border border-line">{@html auto.html}</div>
<p class="hint !mt-0">Passt etwas nicht? Schreib unten eine eigene Fassung – sie hat dann Vorrang.</p>
{/if}
{/if}
</div>
{/if}
{#if aiDraft}
<p class="text-sm rounded-xl bg-accent-soft text-accent-ink px-4 py-3" role="status">
<strong>KI-Entwurf:</strong> Bitte Inhalt prüfen – Fakten, Namen, Daten. Am besten liest eine Person aus der Zielgruppe gegen.
</p>
{/if}
<RichEditor
bind:this={editor}
name="contentEasy"
{value}
label="Text in Leichter Sprache"
label="Eigene Fassung in Leichter Sprache"
hint="Tipps: kurze Sätze, ein Gedanke pro Satz, bekannte Wörter, lange Wörter mit Medio·punkt trennen."
/>
{#if page.data.aiEasy}
<p id="ki-hinweis" class="hint">„Mit KI erstellen“ nimmt den aktuellen Text oben (auch ungespeichert) und schickt ihn zur Bearbeitung an Claude (Anthropic).</p>
{/if}
</div>
</section>

View file

@ -1,29 +1,144 @@
<script lang="ts">
import { untrack } from 'svelte';
import BookHeart from '@lucide/svelte/icons/book-heart';
import Sparkles from '@lucide/svelte/icons/sparkles';
import LoaderCircle from '@lucide/svelte/icons/loader-circle';
import { page } from '$app/state';
import { prefs } from '$lib/prefs.svelte';
import { STREAM_ERROR } from '$lib/easy-language';
/** Zeigt den Text – bei aktivierter „Leichter Sprache“ die einfache Fassung, falls vorhanden. */
let { content, contentEasy, id = 'vorlesen' }: { content: string; contentEasy: string; id?: string } = $props();
/**
* Zeigt den Text – bei „Leichte Sprache“ die eigene Fassung der Redaktion,
* sonst die automatische (KI). Fehlt sie noch, wird sie live übertragen.
*/
let {
content,
contentEasy,
contentEasyAuto = '',
easyAutoPending = false,
kind = 'post',
slug = '',
id = 'vorlesen'
}: {
content: string;
contentEasy: string;
contentEasyAuto?: string;
easyAutoPending?: boolean;
kind?: 'post' | 'page';
slug?: string;
id?: string;
} = $props();
const useEasy = $derived(prefs.current.easy && !!contentEasy);
let auto = $state(untrack(() => contentEasyAuto));
let live = $state('');
let status = $state<'idle' | 'loading' | 'error'>('idle');
let errorText = $state('');
// Bei Navigation zu einem anderen Text zurücksetzen
$effect(() => {
auto = contentEasyAuto;
slug;
untrack(() => {
live = '';
status = 'idle';
});
});
const available = $derived(!!contentEasy || !!auto || easyAutoPending);
const mode = $derived(!prefs.current.easy ? 'normal' : contentEasy ? 'manual' : auto ? 'auto' : easyAutoPending ? 'pending' : 'normal');
// Leichte Sprache gewünscht, aber noch keine Fassung → jetzt übertragen
$effect(() => {
if (mode === 'pending' && status === 'idle') untrack(fetchEasy);
});
async function fetchEasy() {
status = 'loading';
live = '';
const request = () =>
fetch('/api/leichte-sprache', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ typ: kind, slug })
});
try {
const res = await request();
if (!res.ok || !res.body) throw new Error((await res.json().catch(() => null))?.message ?? 'Leichte Sprache ist gerade nicht verfügbar.');
if (res.headers.get('content-type')?.includes('application/json')) {
auto = (await res.json()).html;
status = 'idle';
return;
}
const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
let text = '';
for (;;) {
const { value, done } = await reader.read();
if (done) break;
text += value;
live = text;
}
const err = text.indexOf(STREAM_ERROR);
if (err >= 0) throw new Error(text.slice(err + STREAM_ERROR.length));
// Der gestreamte Text ist rohe Modell-Ausgabe und wird nie als HTML angezeigt –
// angezeigt wird die gespeicherte, bereinigte Fassung
const final = await request();
if (!final.ok || !final.headers.get('content-type')?.includes('application/json')) throw new Error('Leichte Sprache ist gerade nicht verfügbar.');
auto = (await final.json()).html;
status = 'idle';
} catch (e) {
errorText = (e as Error).message;
status = 'error';
}
}
/** Live-Text ohne Tags (halb übertragene Tags am Ende weglassen) */
const liveText = $derived(
live
.replace(/<[^>]*$/, '')
.replace(/<\/(p|h2|h3|li)>/g, '\n')
.replace(/<li>/g, '• ')
.replace(/<[^>]+>/g, '')
.replace(/\n{2,}/g, '\n')
.trim()
);
const reportHref = $derived(`/barrierefreiheit?seite=${encodeURIComponent(page.url.pathname)}#message`);
</script>
{#if contentEasy}
<div class="bg-accent-soft text-accent-ink rounded-full pl-4 pr-5 py-3 flex items-center gap-3 text-sm font-semibold">
<BookHeart class="size-5 shrink-0" />
<span class="flex-1">
{useEasy ? 'Du liest diesen Text in Leichter Sprache.' : 'Diesen Text gibt es auch in Leichter Sprache.'}
{#if available}
<div class="bg-accent-soft text-accent-ink rounded-[1.5rem] pl-4 pr-5 py-3 flex flex-wrap items-center gap-x-3 gap-y-1 text-sm font-semibold">
{#if mode === 'auto' || mode === 'pending'}<Sparkles class="size-5 shrink-0" aria-hidden="true" />{:else}<BookHeart class="size-5 shrink-0" aria-hidden="true" />{/if}
<span class="flex-1 min-w-48">
{#if mode === 'manual'}
Du liest diesen Text in Leichter Sprache.
{:else if mode === 'auto'}
Automatisch in Leichte Sprache übertragen. Es können Fehler darin sein.
{:else if mode === 'pending' && status === 'loading'}
Der Text wird gerade in Leichte Sprache übertragen …
{:else if mode === 'pending' && status === 'error'}
{errorText} Du siehst den normalen Text.
{:else}
Diesen Text gibt es auch in Leichter Sprache.
{/if}
</span>
<button class="font-bold underline underline-offset-2" onclick={() => prefs.set({ easy: !prefs.current.easy })}>
{useEasy ? 'Normale Sprache' : 'Leichte Sprache'}
{#if mode === 'auto'}<a href={reportHref} class="underline underline-offset-2">Fehler melden</a>{/if}
<button class="font-bold underline underline-offset-2 min-h-8" onclick={() => prefs.set({ easy: !prefs.current.easy })}>
{prefs.current.easy ? 'Normale Sprache' : 'Leichte Sprache'}
</button>
</div>
{/if}
{#if useEasy || content}
<div {id} class="rich {useEasy ? 'easy' : ''}">
{@html useEasy ? contentEasy : content}
{#if mode === 'pending' && status === 'loading'}
<div class="rounded-[1.5rem] border-2 border-dashed border-accent/40 p-5" aria-busy="true">
<p class="flex items-center gap-2 text-sm font-semibold text-accent-ink"><LoaderCircle class="size-4 animate-spin" aria-hidden="true" />Bitte kurz warten.</p>
{#if liveText}<p class="mt-3 text-[1.15rem] leading-relaxed whitespace-pre-line">{liveText}</p>{/if}
</div>
{:else}
{@const html = mode === 'manual' ? contentEasy : mode === 'auto' ? auto : content}
{#if html}
<div {id} class="rich {mode === 'manual' || mode === 'auto' ? 'easy' : ''}">
{@html html}
</div>
{/if}
{/if}
<style>

159
src/lib/server/ai.ts Normal file
View file

@ -0,0 +1,159 @@
import Anthropic from '@anthropic-ai/sdk';
import OpenAI from 'openai';
import { eq } from 'drizzle-orm';
import { db } from './db';
import { settings } from './db/schema';
import { decrypt, encrypt } from './secret';
import { getSettings } from './settings';
import { AI_PROVIDERS, type AiProvider } from '$lib/settings';
/**
* Gemeinsame Schnittstelle für die KI-Anbieter.
* Claude über das Anthropic-SDK; OpenAI, DeepSeek und Ollama sprechen die
* OpenAI-kompatible Chat-Schnittstelle und laufen über das OpenAI-SDK.
*/
export type AiConfig = { provider: AiProvider; model: string; baseUrl: string; apiKey: string };
export class AiError extends Error {}
// ─── API-Schlüssel (verschlüsselt, getrennt von den übrigen Einstellungen) ───
const KEY_ROW = 'ai-api-key';
export function storedKey(): string {
const row = db.select().from(settings).where(eq(settings.key, KEY_ROW)).get();
return row ? (decrypt(String(row.value)) ?? '') : '';
}
export function saveKey(plain: string | null) {
if (!plain) db.delete(settings).where(eq(settings.key, KEY_ROW)).run();
else
db.insert(settings)
.values({ key: KEY_ROW, value: encrypt(plain) })
.onConflictDoUpdate({ target: settings.key, set: { value: encrypt(plain) } })
.run();
}
/** Nur die letzten 4 Zeichen, zum Wiedererkennen in der Redaktion */
export function keyHint(): string {
const k = storedKey();
return k ? `••••${k.slice(-4)}` : '';
}
export function currentConfig(): AiConfig {
const s = getSettings();
const p = AI_PROVIDERS[s.aiProvider] ?? AI_PROVIDERS.anthropic;
return {
provider: s.aiProvider,
model: s.aiModel || p.defaultModel,
baseUrl: s.aiBaseUrl || p.defaultBaseUrl,
apiKey: storedKey()
};
}
/** Ist die automatische Leichte Sprache eingeschaltet und vollständig eingerichtet? */
export function aiReady(): boolean {
const s = getSettings();
if (!s.aiEnabled) return false;
const c = currentConfig();
return !!c.model && (!AI_PROVIDERS[c.provider].needsKey || !!c.apiKey) && (c.provider !== 'ollama' || !!c.baseUrl);
}
// ─── Anbieter ─────────────────────────────────────────────────────────────────
function openaiClient(c: AiConfig) {
return new OpenAI({
apiKey: c.apiKey || 'ollama', // Ollama braucht keinen Schlüssel, das SDK aber einen Wert
baseURL: c.baseUrl || undefined,
timeout: 10 * 60e3
});
}
function anthropicClient(c: AiConfig) {
return new Anthropic({ apiKey: c.apiKey, baseURL: c.baseUrl || undefined });
}
/** Text als Stream erzeugen – liefert Textstücke */
export async function* streamText(
c: AiConfig,
system: string,
user: string,
signal?: AbortSignal
): AsyncGenerator<string> {
try {
if (c.provider === 'anthropic') {
// Bei Claude Opus 5 übernimmt bei einer Ablehnung automatisch das empfohlene Ausweichmodell
const withFallback = c.model === 'claude-opus-5';
const stream = anthropicClient(c).beta.messages.stream(
{
model: c.model,
max_tokens: 64000,
...(withFallback ? { betas: ['server-side-fallback-2026-07-01'], fallbacks: 'default' as const } : {}),
system,
messages: [{ role: 'user', content: user }]
},
{ signal }
);
for await (const event of stream) {
if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') yield event.delta.text;
}
const final = await stream.finalMessage();
if (final.stop_reason === 'refusal') throw new AiError('Die KI hat die Bearbeitung abgelehnt.');
if (final.stop_reason === 'max_tokens') throw new AiError('Die Antwort der KI war zu lang und ist unvollständig.');
return;
}
const stream = await openaiClient(c).chat.completions.create(
{
model: c.model,
stream: true,
messages: [
{ role: 'system', content: system },
{ role: 'user', content: user }
]
},
{ signal }
);
let finish: string | null = null;
for await (const chunk of stream) {
const choice = chunk.choices[0];
if (choice?.delta?.content) yield choice.delta.content;
if (choice?.finish_reason) finish = choice.finish_reason;
}
if (finish === 'length') throw new AiError('Die Antwort der KI war zu lang und ist unvollständig.');
if (finish === 'content_filter') throw new AiError('Die KI hat die Bearbeitung abgelehnt.');
} catch (e) {
throw toAiError(e);
}
}
/** Verfügbare Modelle beim Anbieter abfragen (für die Auswahl in den Einstellungen) */
export async function listModels(c: AiConfig): Promise<string[]> {
try {
const ids: string[] = [];
if (c.provider === 'anthropic') {
for await (const m of anthropicClient(c).models.list()) ids.push(m.id);
} else {
for await (const m of openaiClient(c).models.list()) ids.push(m.id);
}
return ids.sort();
} catch (e) {
throw toAiError(e);
}
}
function toAiError(e: unknown): Error {
if (e instanceof AiError) return e;
const status = (e as { status?: number }).status;
const name = (e as Error)?.name ?? '';
if (name === 'APIUserAbortError' || name === 'AbortError') return e as Error;
if (status === 401 || status === 403) return new AiError('Der API-Schlüssel wird nicht akzeptiert.');
if (status === 404) return new AiError('Das Modell oder die Adresse wurde nicht gefunden.');
if (status === 429) return new AiError('Der Anbieter meldet: zu viele Anfragen oder kein Guthaben.');
if (status && status >= 500) return new AiError('Der KI-Dienst hat gerade eine Störung.');
if (name === 'APIConnectionError' || name === 'APIConnectionTimeoutError')
return new AiError('Der KI-Dienst ist nicht erreichbar. Adresse prüfen.');
console.error('[ki]', e);
return new AiError('Unerwarteter Fehler bei der KI.');
}

View file

@ -4,6 +4,7 @@ import { contacts, events, media, pages, posts, type Attachment, type Media, typ
import { mediaUrl, thumbUrl } from './uploads';
import type { AttachmentItem, ContactCard, EventItem, MediaItem, PageCard, PostCard } from '$lib/types';
import { today } from '$lib/dates';
import { isFresh, needsAuto } from './easy-auto';
export function toMediaItem(m: Media): MediaItem {
return {
@ -115,6 +116,8 @@ export function getPost(slug: string) {
teaser: post.teaser,
content: post.content,
contentEasy: post.contentEasy,
contentEasyAuto: isFresh(post) ? post.contentEasyAuto : '',
easyAutoPending: needsAuto(post),
videoUrl: post.videoUrl,
publishedAt: post.publishedAt.toISOString(),
cover: getMedia(post.coverId),
@ -167,6 +170,8 @@ export function getPage(slug: string) {
color: page.color,
content: page.content,
contentEasy: page.contentEasy,
contentEasyAuto: isFresh(page) ? page.contentEasyAuto : '',
easyAutoPending: needsAuto(page),
cover: getMedia(page.coverId),
attachments: attachmentsOf(page.attachments),
contacts: contactsByIds(page.contactIds),

View file

@ -116,6 +116,12 @@ export const pages = sqliteTable(
content: text('content').notNull().default(''),
/** Optionale Fassung in Leichter Sprache */
contentEasy: text('content_easy').notNull().default(''),
/** Automatische Fassung in Leichter Sprache (KI) – nur genutzt, wenn contentEasy leer ist */
contentEasyAuto: text('content_easy_auto').notNull().default(''),
/** Prüfsumme des Ausgangstextes – passt sie nicht mehr, wird neu übertragen */
contentEasyAutoHash: text('content_easy_auto_hash').notNull().default(''),
contentEasyAutoModel: text('content_easy_auto_model').notNull().default(''),
contentEasyAutoAt: integer('content_easy_auto_at', { mode: 'timestamp' }),
attachments: text('attachments', { mode: 'json' }).$type<Attachment[]>().notNull().default([]),
contactIds: text('contact_ids', { mode: 'json' }).$type<number[]>().notNull().default([]),
sortOrder: integer('sort_order').notNull().default(0),
@ -137,6 +143,12 @@ export const posts = sqliteTable(
coverId: integer('cover_id').references(() => media.id, { onDelete: 'set null' }),
content: text('content').notNull().default(''),
contentEasy: text('content_easy').notNull().default(''),
/** Automatische Fassung in Leichter Sprache (KI) – nur genutzt, wenn contentEasy leer ist */
contentEasyAuto: text('content_easy_auto').notNull().default(''),
/** Prüfsumme des Ausgangstextes – passt sie nicht mehr, wird neu übertragen */
contentEasyAutoHash: text('content_easy_auto_hash').notNull().default(''),
contentEasyAutoModel: text('content_easy_auto_model').notNull().default(''),
contentEasyAutoAt: integer('content_easy_auto_at', { mode: 'timestamp' }),
/** YouTube-/Vimeo-Link oder leer */
videoUrl: text('video_url').notNull().default(''),
gallery: text('gallery', { mode: 'json' }).$type<number[]>().notNull().default([]),

192
src/lib/server/easy-auto.ts Normal file
View file

@ -0,0 +1,192 @@
import { createHash } from 'node:crypto';
import { eq } from 'drizzle-orm';
import { db } from './db';
import { pages, posts } from './db/schema';
import { AiError, aiReady, currentConfig, streamText } from './ai';
import { attempts, record } from './ratelimit';
import { cleanHtml } from './sanitize';
import { getSettings } from './settings';
/**
* Automatische Fassung in Leichter Sprache für Leser.
* Eine eigene (geprüfte) Fassung aus der Redaktion hat immer Vorrang.
*/
export type EasyKind = 'post' | 'page';
/** Bei Änderungen an den Anweisungen erhöhen → alles wird nach und nach neu übertragen */
const PROMPT_VERSION = 1;
const MAX_INPUT_CHARS = 60_000;
const DAY = 864e5;
const table = (kind: EasyKind) => (kind === 'post' ? posts : pages);
function systemPrompt(address: 'du' | 'Sie') {
return `Du überträgst Texte für die Info-App einer Werkstatt für Menschen mit Behinderung in Leichte Sprache.
Die Leserinnen und Leser sind Beschäftigte der Werkstatt, viele mit Lernschwierigkeiten.
Halte dich an die Regeln für Leichte Sprache (Netzwerk Leichte Sprache, DIN SPEC 33429):
- Kurze Sätze. Ein Satz enthält nur eine Aussage.
- Einfache, bekannte Wörter. Immer dieselben Wörter für dieselbe Sache.
- Schwere Wörter, die nötig sind, erklärst du im nächsten Satz.
- Lange zusammengesetzte Wörter trennst du mit dem Medio·punkt, z. B. Werkstatt·rat, Sommer·fest.
- Aktiv statt passiv. Kein Konjunktiv. Kein Genitiv – schreib „von“ oder „vom“.
- Positiv formulieren, Verneinungen vermeiden, wo es geht.
- Zahlen als Ziffern. Datum so: 5. Oktober 2026. Uhrzeit so: 10 Uhr oder 10:30 Uhr.
- Keine Abkürzungen, keine Fremdwörter, keine Redewendungen, keine Sonderzeichen wie & oder %.
- Sprich die Leserinnen und Leser mit „${address}“ an.
- Wichtiges zuerst. Gliedere mit kurzen Zwischenüberschriften, wenn der Text länger ist.
Inhalt:
- Übernimm alle wichtigen Informationen: wer, was, wann, wo, Kontakt.
- Erfinde nichts dazu. Lass Unwichtiges weg.
- Namen, Orte, Daten, Uhrzeiten, Telefonnummern und E-Mail-Adressen übernimmst du genau.
Format:
- Antworte nur mit dem fertigen Text als HTML, ohne Einleitung, ohne Erklärung und ohne Code-Block.
- Erlaubt sind nur diese Tags: <h2>, <h3>, <p>, <ul>, <li>, <strong>.
- Jeder Satz steht in einem eigenen <p>. Aufzählungen als <ul> mit <li>.`;
}
/** HTML → Text mit Struktur (Überschriften, Listen), damit das Modell keine Tags übernimmt */
function htmlToStructuredText(html: string): string {
return html
.replace(/<\s*(h2|h3)[^>]*>/gi, '\n\n## ')
.replace(/<\s*li[^>]*>/gi, '\n- ')
.replace(/<\s*(p|br|div|blockquote)[^>]*>/gi, '\n')
.replace(/<[^>]+>/g, '')
.replace(/&nbsp;/g, ' ')
.replace(/&amp;/g, '&')
.replace(/&lt;/g, '<')
.replace(/&gt;/g, '>')
.replace(/&quot;/g, '"')
.replace(/\n{3,}/g, '\n\n')
.trim();
}
/** Prüfsumme über alles, was das Ergebnis beeinflusst */
export function sourceHash(title: string, html: string): string {
const s = getSettings();
return createHash('sha256').update(JSON.stringify([PROMPT_VERSION, s.easyAddress, title, html])).digest('hex');
}
type Row = { id: number; title: string; content: string; contentEasy: string; contentEasyAuto: string; contentEasyAutoHash: string; published: boolean };
function load(kind: EasyKind, id: number): Row | undefined {
const t = table(kind);
return db
.select({
id: t.id,
title: t.title,
content: t.content,
contentEasy: t.contentEasy,
contentEasyAuto: t.contentEasyAuto,
contentEasyAutoHash: t.contentEasyAutoHash,
published: t.published
})
.from(t)
.where(eq(t.id, id))
.get();
}
/** Hat der Text eine aktuelle automatische Fassung? */
export const isFresh = (r: Pick<Row, 'title' | 'content' | 'contentEasyAuto' | 'contentEasyAutoHash'>) =>
!!r.contentEasyAuto && r.contentEasyAutoHash === sourceHash(r.title, r.content);
/** Braucht der Text eine (neue) automatische Fassung? */
export const needsAuto = (r: Pick<Row, 'title' | 'content' | 'contentEasy' | 'contentEasyAuto' | 'contentEasyAutoHash'>) =>
aiReady() && !r.contentEasy.trim() && !!htmlToStructuredText(r.content) && !isFresh(r);
// ─── Erzeugen ────────────────────────────────────────────────────────────────
const inFlight = new Map<string, Promise<string>>();
export function dailyUsage() {
return attempts('ki-tag', DAY);
}
/**
* Überträgt einen Text und speichert das Ergebnis. Läuft schon eine Übertragung
* für denselben Text, wird auf diese gewartet. `onChunk` bekommt die Textstücke live.
*/
export function generate(kind: EasyKind, id: number, onChunk?: (t: string) => void): Promise<string> {
const key = `${kind}:${id}`;
const running = inFlight.get(key);
if (running) return running;
const job = (async () => {
const row = load(kind, id);
if (!row) throw new AiError('Text nicht gefunden.');
if (isFresh(row)) return row.contentEasyAuto;
if (!aiReady()) throw new AiError('Die automatische Leichte Sprache ist nicht eingerichtet.');
const text = htmlToStructuredText(row.content);
if (!text) throw new AiError('Es gibt keinen Text zum Übertragen.');
// Nichts still abschneiden – sehr lange Texte werden nicht automatisch übertragen
if (text.length > MAX_INPUT_CHARS) throw new AiError('Der Text ist zu lang für eine automatische Übertragung.');
if (dailyUsage() >= getSettings().aiDailyLimit) throw new AiError('Das Tageslimit für automatische Übertragungen ist erreicht.');
record('ki-tag');
const hash = sourceHash(row.title, row.content);
const config = currentConfig();
let out = '';
for await (const chunk of streamText(
config,
systemPrompt(getSettings().easyAddress),
`Übertrage diesen Text in Leichte Sprache.\n\n<titel>${row.title}</titel>\n\n<text>\n${text}\n</text>`
)) {
out += chunk;
onChunk?.(chunk);
}
// Falls das Modell doch einen Code-Block drumherum schreibt
const html = cleanHtml(out.replace(/^\s*```(?:html)?\s*/i, '').replace(/```\s*$/, ''));
if (!html) throw new AiError('Die KI hat keinen Text geliefert.');
const t = table(kind);
db.update(t)
.set({ contentEasyAuto: html, contentEasyAutoHash: hash, contentEasyAutoModel: `${config.provider}/${config.model}`, contentEasyAutoAt: new Date() })
.where(eq(t.id, id))
.run();
return html;
})().finally(() => inFlight.delete(key));
inFlight.set(key, job);
return job;
}
// ─── Hintergrund-Warteschlange (beim Speichern) ──────────────────────────────
const queue: { kind: EasyKind; id: number }[] = [];
let working = false;
/** Nach dem Speichern vormerken – Leser müssen dann meist nicht warten */
export function queueAuto(kind: EasyKind, id: number) {
const row = load(kind, id);
if (!row || !row.published || !needsAuto(row)) return;
if (!queue.some((q) => q.kind === kind && q.id === id)) queue.push({ kind, id });
if (!working) void work();
}
async function work() {
working = true;
while (queue.length) {
const next = queue.shift()!;
try {
await generate(next.kind, next.id);
} catch (e) {
console.warn(`[leichte-sprache] ${next.kind} ${next.id}:`, (e as Error).message);
}
}
working = false;
}
/** Stand der automatischen Fassung für die Anzeige in der Redaktion */
export function autoStatus(r: { title: string; content: string; contentEasyAuto: string; contentEasyAutoHash: string; contentEasyAutoModel: string; contentEasyAutoAt: Date | null }) {
return {
enabled: getSettings().aiEnabled,
html: r.contentEasyAuto,
fresh: isFresh(r),
at: r.contentEasyAutoAt?.toISOString() ?? null,
model: r.contentEasyAutoModel
};
}

View file

@ -1,115 +0,0 @@
import Anthropic from '@anthropic-ai/sdk';
import { getSettings } from './settings';
/**
* Entwürfe in Leichter Sprache mit Claude.
* Braucht ANTHROPIC_API_KEY in der .env. Ohne Schlüssel ist die Funktion
* in der Redaktion einfach ausgeblendet.
*/
const MODEL = 'claude-opus-5';
/** Längere Texte bitte in Abschnitten übertragen – nichts wird still abgeschnitten */
export const MAX_INPUT_CHARS = 60_000;
let client: Anthropic | null = null;
export const easyLanguageAvailable = () => !!(process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN);
function anthropic() {
client ??= new Anthropic();
return client;
}
function systemPrompt(address: 'du' | 'Sie') {
return `Du überträgst Texte für die Info-App einer Werkstatt für Menschen mit Behinderung in Leichte Sprache.
Die Leserinnen und Leser sind Beschäftigte der Werkstatt, viele mit Lernschwierigkeiten.
Halte dich an die Regeln für Leichte Sprache (Netzwerk Leichte Sprache, DIN SPEC 33429):
- Kurze Sätze. Ein Satz enthält nur eine Aussage.
- Einfache, bekannte Wörter. Immer dieselben Wörter für dieselbe Sache.
- Schwere Wörter, die nötig sind, erklärst du im nächsten Satz.
- Lange zusammengesetzte Wörter trennst du mit dem Medio·punkt, z. B. Werkstatt·rat, Sommer·fest.
- Aktiv statt passiv. Kein Konjunktiv. Kein Genitiv – schreib „von“ oder „vom“.
- Positiv formulieren, Verneinungen vermeiden, wo es geht.
- Zahlen als Ziffern. Datum so: 5. Oktober 2026. Uhrzeit so: 10 Uhr oder 10:30 Uhr.
- Keine Abkürzungen, keine Fremdwörter, keine Redewendungen, keine Sonderzeichen wie & oder %.
- Sprich die Leserinnen und Leser mit „${address}“ an.
- Wichtiges zuerst. Gliedere mit kurzen Zwischenüberschriften, wenn der Text länger ist.
Inhalt:
- Übernimm alle wichtigen Informationen: wer, was, wann, wo, Kontakt.
- Erfinde nichts dazu. Lass Unwichtiges weg.
- Namen, Orte, Daten, Uhrzeiten, Telefonnummern und E-Mail-Adressen übernimmst du genau.
Format:
- Antworte nur mit dem fertigen Text als HTML, ohne Einleitung, ohne Erklärung und ohne Code-Block.
- Erlaubt sind nur diese Tags: <h2>, <h3>, <p>, <ul>, <li>, <strong>.
- Jeder Satz steht in einem eigenen <p>. Aufzählungen als <ul> mit <li>.`;
}
/** Entfernt Tags für die Eingabe – das Modell bekommt nur Überschrift und Textinhalt mit Struktur */
function htmlToStructuredText(html: string): string {
return html
.replace(/<\s*(h2|h3)[^>]*>/gi, '\n\n## ')
.replace(/<\s*li[^>]*>/gi, '\n- ')
.replace(/<\s*(p|br|div|blockquote)[^>]*>/gi, '\n')
.replace(/<[^>]+>/g, '')
.replace(/&nbsp;/g, ' ')
.replace(/&amp;/g, '&')
.replace(/&lt;/g, '<')
.replace(/&gt;/g, '>')
.replace(/&quot;/g, '"')
.replace(/\n{3,}/g, '\n\n')
.trim();
}
export class EasyLanguageError extends Error {}
/**
* Streamt den Entwurf in Leichter Sprache als HTML-Textstücke.
* Wirft EasyLanguageError mit verständlicher Meldung.
*/
export async function* streamEasyLanguage(input: { title: string; html: string }, signal?: AbortSignal): AsyncGenerator<string> {
const text = htmlToStructuredText(input.html);
if (!text) throw new EasyLanguageError('Es gibt noch keinen Text, der übertragen werden kann.');
if (text.length > MAX_INPUT_CHARS)
throw new EasyLanguageError(`Der Text ist zu lang (${text.length.toLocaleString('de-DE')} Zeichen). Bitte in kürzeren Abschnitten übertragen.`);
const s = getSettings();
const stream = anthropic().beta.messages.stream(
{
model: MODEL,
max_tokens: 64000,
// Bei einer Ablehnung durch die Sicherheitsprüfung übernimmt automatisch das empfohlene Ausweichmodell
betas: ['server-side-fallback-2026-07-01'],
fallbacks: 'default',
system: systemPrompt(s.easyAddress),
messages: [
{
role: 'user',
content: `Übertrage diesen Text in Leichte Sprache.\n\n<titel>${input.title}</titel>\n\n<text>\n${text}\n</text>`
}
]
},
{ signal }
);
try {
for await (const event of stream) {
if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') yield event.delta.text;
}
const final = await stream.finalMessage();
if (final.stop_reason === 'refusal') throw new EasyLanguageError('Die KI konnte diesen Text nicht bearbeiten. Bitte selbst übertragen.');
if (final.stop_reason === 'max_tokens') throw new EasyLanguageError('Der Entwurf wurde zu lang und ist unvollständig. Bitte den Text in Abschnitten übertragen.');
} catch (e) {
if (e instanceof EasyLanguageError) throw e;
if (e instanceof Anthropic.AuthenticationError) throw new EasyLanguageError('Der KI-Zugang ist ungültig. Bitte ANTHROPIC_API_KEY prüfen.');
if (e instanceof Anthropic.RateLimitError) throw new EasyLanguageError('Die KI ist gerade ausgelastet. Bitte in einer Minute noch einmal versuchen.');
if (e instanceof Anthropic.APIUserAbortError) return;
if (e instanceof Anthropic.APIError) {
console.error('[leichte-sprache] API-Fehler', e.status, e.message);
throw new EasyLanguageError('Die KI ist gerade nicht erreichbar. Bitte später noch einmal versuchen.');
}
throw e;
}
}

View file

@ -1,4 +1,4 @@
import type { AppSettings } from '$lib/settings';
import { AI_PROVIDERS, type AppSettings } from '$lib/settings';
import { formatDate, today } from '$lib/dates';
/**
@ -63,10 +63,17 @@ export function privacyTemplate(s: AppSettings): string {
'<h2>6. Vorlesen</h2>',
'<p>Die Vorlesefunktion nutzt die Sprachausgabe deines Geräts. Wir bevorzugen Stimmen, die direkt auf dem Gerät arbeiten. Steht nur eine Online-Stimme des Browsers zur Verfügung, kann der vorgelesene Text vom Browser-Anbieter verarbeitet werden. Wir selbst erhalten dabei keine Daten.</p>',
'<h2>7. Eingebettete Videos</h2>',
s.aiEnabled
? `<h2>7. Automatische Leichte Sprache</h2><p>Texte, die es noch nicht in Leichter Sprache gibt, überträgt eine KI automatisch. Dafür werden die veröffentlichten Texte der App an ${
s.aiProvider === 'ollama'
? 'einen KI-Dienst auf einem eigenen Server des Verantwortlichen'
: `den Anbieter ${esc(AI_PROVIDERS[s.aiProvider].label)} (Verarbeitung auch außerhalb der EU möglich, auf Grundlage eines Auftragsverarbeitungsvertrags)`
} übermittelt. Von dir als Leserin oder Leser werden dabei keine Daten übermittelt. Automatisch übertragene Texte sind in der App gekennzeichnet.</p>`
: '',
`<h2>${s.aiEnabled ? 8 : 7}. Eingebettete Videos</h2>`,
'<p>Videos von YouTube (im erweiterten Datenschutzmodus, youtube-nocookie.com) oder Vimeo werden erst geladen, wenn du auf „Video abspielen“ tippst. Erst dann wird eine Verbindung zum jeweiligen Anbieter hergestellt, der dabei u. a. deine IP-Adresse erhält und Daten auch in den USA verarbeiten kann (Einwilligung, Art. 6 Abs. 1 lit. a DSGVO).</p>',
'<h2>8. Deine Rechte</h2>',
`<h2>${s.aiEnabled ? 9 : 8}. Deine Rechte</h2>`,
'<p>Du hast das Recht auf Auskunft, Berichtigung, Löschung und Einschränkung der Verarbeitung, auf Datenübertragbarkeit sowie auf Widerspruch gegen Verarbeitungen, die auf berechtigtem Interesse beruhen. Eine Einwilligung kannst du jederzeit mit Wirkung für die Zukunft widerrufen. Schreib uns dazu einfach über die oben genannten Kontaktdaten.</p>',
`<p>Außerdem kannst du dich bei einer Datenschutz-Aufsichtsbehörde beschweren${l.supervisory ? `, zum Beispiel bei der für uns zuständigen: ${esc(l.supervisory)}` : ''}.</p>`,

View file

@ -1,4 +1,4 @@
import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
import { createCipheriv, createDecipheriv, createHmac, hkdfSync, randomBytes, timingSafeEqual } from 'node:crypto';
import { eq } from 'drizzle-orm';
import { db } from './db';
import { settings } from './db/schema';
@ -32,3 +32,25 @@ export function unsign(signed: string | undefined): string | null {
const actual = Buffer.from(signed.slice(i + 1));
return expected.length === actual.length && timingSafeEqual(expected, actual) ? value : null;
}
// ─── Verschlüsselung gespeicherter Zugangsdaten (z. B. KI-Schlüssel) ─────────
const encKey = () => Buffer.from(hkdfSync('sha256', secret(), Buffer.alloc(0), 'werkstatt-app:verschluesselung', 32));
export function encrypt(plain: string): string {
const iv = randomBytes(12);
const cipher = createCipheriv('aes-256-gcm', encKey(), iv);
const data = Buffer.concat([cipher.update(plain, 'utf8'), cipher.final()]);
return [iv, cipher.getAuthTag(), data].map((b) => b.toString('base64url')).join('.');
}
export function decrypt(stored: string): string | null {
try {
const [iv, tag, data] = stored.split('.').map((x) => Buffer.from(x, 'base64url'));
const decipher = createDecipheriv('aes-256-gcm', encKey(), iv);
decipher.setAuthTag(tag);
return Buffer.concat([decipher.update(data), decipher.final()]).toString('utf8');
} catch {
return null;
}
}

View file

@ -1,3 +1,12 @@
/** KI-Anbieter für die automatische Leichte Sprache */
export const AI_PROVIDERS = {
anthropic: { label: 'Anthropic (Claude)', defaultModel: 'claude-opus-5', defaultBaseUrl: '', needsKey: true },
openai: { label: 'OpenAI', defaultModel: '', defaultBaseUrl: '', needsKey: true },
deepseek: { label: 'DeepSeek', defaultModel: 'deepseek-chat', defaultBaseUrl: 'https://api.deepseek.com', needsKey: true },
ollama: { label: 'Ollama (eigener Server)', defaultModel: '', defaultBaseUrl: 'http://localhost:11434/v1', needsKey: false }
} as const;
export type AiProvider = keyof typeof AI_PROVIDERS;
/** Angaben zur Einrichtung – daraus entstehen Impressum und Datenschutzerklärung */
export type LegalInfo = {
name: string;
@ -53,7 +62,15 @@ export type AppSettings = {
/** Wie viele Meldungen/Termine die Startseite zeigt */
/** Administratoren müssen die Zwei-Faktor-Anmeldung einrichten */
require2faAdmins: boolean;
/** Anrede in den KI-Entwürfen für Leichte Sprache */
/** Automatische Leichte Sprache per KI für Leser */
aiEnabled: boolean;
aiProvider: AiProvider;
aiModel: string;
/** Adresse des Dienstes (Ollama oder eigener Endpunkt), leer = Standard des Anbieters */
aiBaseUrl: string;
/** Höchstens so viele Übertragungen pro Tag (Kostenschutz) */
aiDailyLimit: number;
/** Anrede in den Texten in Leichter Sprache */
easyAddress: 'du' | 'Sie';
homeNewsCount: number;
homeEventsCount: number;
@ -97,6 +114,11 @@ export const DEFAULT_SETTINGS: AppSettings = {
enforcement: ''
},
require2faAdmins: false,
aiEnabled: false,
aiProvider: 'anthropic',
aiModel: '',
aiBaseUrl: '',
aiDailyLimit: 100,
easyAddress: 'du',
homeNewsCount: 4,
homeEventsCount: 4

View file

@ -39,7 +39,7 @@
{/if}
<div class="space-y-8">
<RichContent content={post.content} contentEasy={post.contentEasy} />
<RichContent content={post.content} contentEasy={post.contentEasy} contentEasyAuto={post.contentEasyAuto} easyAutoPending={post.easyAutoPending} kind="post" slug={post.slug} />
{#if post.videoUrl}<VideoEmbed url={post.videoUrl} />{/if}
<Gallery images={post.gallery} />
<Attachments items={post.attachments} />

View file

@ -40,7 +40,7 @@
{/if}
<div class="space-y-8">
<RichContent content={p.content} contentEasy={p.contentEasy} />
<RichContent content={p.content} contentEasy={p.contentEasy} contentEasyAuto={p.contentEasyAuto} easyAutoPending={p.easyAutoPending} kind="page" slug={p.slug} />
{#if p.children.length}
<section class="space-y-3">

View file

@ -1,10 +1,8 @@
import { eq, sql } from 'drizzle-orm';
import { db } from '$lib/server/db';
import { messages } from '$lib/server/db/schema';
import { easyLanguageAvailable } from '$lib/server/easy-language';
export const load = ({ locals }) => ({
user: locals.user!,
aiEasy: easyLanguageAvailable(),
unread: db.select({ n: sql<number>`count(*)` }).from(messages).where(eq(messages.read, false)).get()?.n ?? 0
});

View file

@ -5,12 +5,14 @@ import { fields, requireAdmin } from '$lib/server/forms';
import { cleanHtml } from '$lib/server/sanitize';
import { imprintTemplate, privacyTemplate } from '$lib/server/legal';
import type { AppSettings } from '$lib/settings';
import { easyLanguageAvailable } from '$lib/server/easy-language';
import { aiReady, keyHint, saveKey } from '$lib/server/ai';
import { dailyUsage } from '$lib/server/easy-auto';
import { AI_PROVIDERS, type AiProvider } from '$lib/settings';
export const load = ({ locals }) => {
requireAdmin(locals.user);
const s = getSettings();
return { settings: s, logo: getMedia(s.logoId), hero: getMedia(s.heroImageId), ai: easyLanguageAvailable() };
return { settings: s, logo: getMedia(s.logoId), hero: getMedia(s.heroImageId), ai: { ready: aiReady(), keyHint: keyHint(), usedToday: dailyUsage() } };
};
/** Liest alle Felder des Formulars – oder gibt eine Fehlermeldung zurück */
@ -44,6 +46,11 @@ function read(form: FormData): Partial<AppSettings> | string {
privacy: cleanHtml(f.html('privacy')),
require2faAdmins: f.bool('require2faAdmins'),
easyAddress: f.str('easyAddress') === 'Sie' ? 'Sie' : 'du',
aiEnabled: f.bool('aiEnabled'),
aiProvider: (f.str('aiProvider') in AI_PROVIDERS ? f.str('aiProvider') : 'anthropic') as AiProvider,
aiModel: f.str('aiModel', 120),
aiBaseUrl: f.str('aiBaseUrl', 300),
aiDailyLimit: Math.min(5000, Math.max(0, f.int('aiDailyLimit') ?? 100)),
homeNewsCount: Math.min(12, Math.max(0, f.int('homeNewsCount') ?? 4)),
homeEventsCount: Math.min(12, Math.max(0, f.int('homeEventsCount') ?? 4)),
legal: {
@ -73,8 +80,14 @@ function read(form: FormData): Partial<AppSettings> | string {
export const actions = {
save: async ({ request, locals }) => {
requireAdmin(locals.user);
const patch = read(await request.formData());
const form = await request.formData();
const patch = read(form);
if (typeof patch === 'string') return fail(400, { error: patch });
if (patch.aiBaseUrl && !/^https?:\/\//.test(patch.aiBaseUrl)) return fail(400, { error: 'Die KI-Adresse muss mit http:// oder https:// beginnen.' });
const f = fields(form);
// Schlüssel nur ändern, wenn ein neuer eingegeben oder Löschen gewählt wurde
if (f.bool('aiKeyDelete')) saveKey(null);
else if (f.str('aiKey', 500)) saveKey(f.str('aiKey', 500));
saveSettings(patch);
return { saved: true };
},

View file

@ -5,6 +5,7 @@
import ImageField from '$lib/admin/ImageField.svelte';
import RichEditor from '$lib/admin/RichEditor.svelte';
import Switch from '$lib/admin/Switch.svelte';
import AiSettings from '$lib/admin/AiSettings.svelte';
let { data } = $props();
const s = $derived(data.settings);
@ -93,20 +94,8 @@
</div>
</Panel>
<Panel title="Leichte Sprache mit KI" description="Erstellt per Knopfdruck einen Entwurf in Leichter Sprache aus dem normalen Text (Claude von Anthropic).">
{#if data.ai}
<p class="text-sm rounded-xl bg-surface-2 px-4 py-3">Eingerichtet. In Seiten und Meldungen gibt es bei „Leichte Sprache“ den Knopf <strong>„Mit KI erstellen“</strong>.</p>
{:else}
<p class="text-sm rounded-xl bg-accent-soft text-accent-ink px-4 py-3">Noch nicht eingerichtet: Auf dem Server fehlt <code>ANTHROPIC_API_KEY</code> in der <code>.env</code>.</p>
{/if}
<fieldset>
<legend class="label">Anrede in den Entwürfen</legend>
<div class="flex gap-4">
{#each ['du', 'Sie'] as a (a)}
<label class="inline-flex items-center gap-2 cursor-pointer"><input type="radio" name="easyAddress" value={a} checked={s.easyAddress === a} class="accent-[var(--brand)]" />„{a}“</label>
{/each}
</div>
</fieldset>
<Panel title="Leichte Sprache mit KI" description="Überträgt Texte ohne eigene Fassung automatisch für Leser in Leichte Sprache. Eigene Fassungen aus der Redaktion haben immer Vorrang.">
<AiSettings {s} ai={data.ai} />
</Panel>
<Panel title="Sicherheit">

View file

@ -5,6 +5,8 @@ import { posts } from '$lib/server/db/schema';
import { attachmentsOf, contactOptions as listContactOptions, getMedia, mediaByIds } from '$lib/server/content';
import { fields, parseId, uniqueSlug } from '$lib/server/forms';
import { cleanHtml } from '$lib/server/sanitize';
import { autoStatus, queueAuto } from '$lib/server/easy-auto';
import { getSettings } from '$lib/server/settings';
import { fromLocalInput, toLocalInput } from '$lib/dates';
import { sendDuePosts, subscriberCounts } from '$lib/server/push';
import type { MediaItem } from '$lib/types';
@ -16,6 +18,7 @@ export const load = ({ params }) => {
if (id === 'new') {
return {
isNew: true,
easyAuto: { enabled: getSettings().aiEnabled, html: '', fresh: false, at: null, model: '' } as ReturnType<typeof autoStatus>,
subscribers: subscriberCounts().byTopic.news,
contactOptions,
post: {
@ -31,6 +34,7 @@ export const load = ({ params }) => {
const gallery = mediaByIds(p.gallery);
return {
isNew: false,
easyAuto: autoStatus(p),
subscribers: subscriberCounts().byTopic.news,
contactOptions,
post: {
@ -72,11 +76,13 @@ export const actions = {
if (id === 'new') {
const created = db.insert(posts).values(values).returning({ id: posts.id }).get();
await sendDuePosts();
queueAuto('post', created.id);
redirect(303, `/admin/meldungen/${created.id}`);
}
db.update(posts).set(values).where(eq(posts.id, id)).run();
// Ist die Meldung jetzt erschienen und soll benachrichtigen? Dann sofort senden.
await sendDuePosts();
queueAuto('post', id);
return { saved: true };
},
delete: ({ params }) => {

View file

@ -37,7 +37,7 @@
<RichEditor name="content" value={p.content} label="Text" />
</Panel>
<EasyLanguageField value={p.contentEasy} />
<EasyLanguageField value={p.contentEasy} auto={data.easyAuto} />
<Panel title="Medien & Anhänge">
<GalleryField name="gallery" value={p.gallery} />

View file

@ -5,6 +5,8 @@ import { pages } from '$lib/server/db/schema';
import { attachmentsOf, contactOptions as listContactOptions, getMedia } from '$lib/server/content';
import { fields, parseId, uniqueSlug } from '$lib/server/forms';
import { cleanHtml } from '$lib/server/sanitize';
import { autoStatus, queueAuto } from '$lib/server/easy-auto';
import { getSettings } from '$lib/server/settings';
import { descendantsOf, pageTree } from '$lib/server/pageTree';
import { nextSortOrder } from '$lib/server/sorting';
import { isTone } from '$lib/palette';
@ -23,6 +25,7 @@ export const load = ({ params, url }) => {
const parent = Number(url.searchParams.get('parent')) || null;
return {
isNew: true, contactOptions, parentOptions,
easyAuto: { enabled: getSettings().aiEnabled, html: '', fresh: false, at: null, model: '' } as ReturnType<typeof autoStatus>,
page: {
id: 0, parentId: parent, title: '', slug: '', teaser: '', icon: 'file-text', color: 'sky', content: '', contentEasy: '',
published: true, cover: null as MediaItem | null, attachments: [] as ReturnType<typeof attachmentsOf>, contactIds: [] as number[]
@ -34,6 +37,7 @@ export const load = ({ params, url }) => {
if (!p) error(404, 'Seite nicht gefunden');
return {
isNew: false, contactOptions, parentOptions,
easyAuto: autoStatus(p),
page: {
id: p.id, parentId: p.parentId, title: p.title, slug: p.slug, teaser: p.teaser, icon: p.icon, color: p.color,
content: p.content, contentEasy: p.contentEasy, published: p.published,
@ -72,6 +76,7 @@ export const actions = {
if (id === 'new') {
const scope = parentId ? eq(pages.parentId, parentId) : isNull(pages.parentId);
const created = db.insert(pages).values({ ...values, sortOrder: nextSortOrder(pages, scope) }).returning({ id: pages.id }).get();
queueAuto('page', created.id);
redirect(303, `/admin/seiten/${created.id}`);
}
const before = db.select({ parentId: pages.parentId }).from(pages).where(eq(pages.id, id)).get();
@ -81,6 +86,7 @@ export const actions = {
.set(moved ? { ...values, sortOrder: nextSortOrder(pages, scope) } : values)
.where(eq(pages.id, id))
.run();
queueAuto('page', id);
return { saved: true };
},
delete: ({ params }) => {

View file

@ -45,7 +45,7 @@
<RichEditor name="content" value={p.content} label="Inhalt" hint="Darf leer bleiben, wenn die Seite nur Unterseiten zeigt." />
</Panel>
<EasyLanguageField value={p.contentEasy} />
<EasyLanguageField value={p.contentEasy} auto={data.easyAuto} />
<Panel title="Anhänge & Ansprechpartner">
<AttachmentsField name="attachments" value={p.attachments} />

View file

@ -0,0 +1,16 @@
import { currentConfig, type AiConfig } from '$lib/server/ai';
import { AI_PROVIDERS, type AiProvider } from '$lib/settings';
/** Konfiguration aus dem (noch ungespeicherten) Formular – ohne Schlüssel gilt der gespeicherte */
export function configFrom(body: Record<string, unknown> | null): AiConfig {
const stored = currentConfig();
const provider = (typeof body?.provider === 'string' && body.provider in AI_PROVIDERS ? body.provider : stored.provider) as AiProvider;
const p = AI_PROVIDERS[provider];
const str = (v: unknown) => (typeof v === 'string' ? v.trim() : '');
return {
provider,
model: str(body?.model) || p.defaultModel,
baseUrl: str(body?.baseUrl) || p.defaultBaseUrl,
apiKey: str(body?.apiKey) || stored.apiKey
};
}

View file

@ -0,0 +1,13 @@
import { error, json } from '@sveltejs/kit';
import { requireAdmin } from '$lib/server/forms';
import { AiError, listModels } from '$lib/server/ai';
import { configFrom } from '../config';
export const POST = async ({ request, locals }) => {
requireAdmin(locals.user);
try {
return json({ models: await listModels(configFrom(await request.json().catch(() => null))) });
} catch (e) {
error(400, e instanceof AiError ? e.message : 'Modelle konnten nicht geladen werden.');
}
};

View file

@ -0,0 +1,26 @@
import { error, json } from '@sveltejs/kit';
import { requireAdmin } from '$lib/server/forms';
import { AiError, streamText } from '$lib/server/ai';
import { allow } from '$lib/server/ratelimit';
import { configFrom } from '../config';
/** Kurzer Probelauf mit einem Satz – kostet nur Bruchteile eines Cents */
export const POST = async ({ request, locals }) => {
requireAdmin(locals.user);
if (!allow(`ki-test:${locals.user!.id}`, 20, 3600e3)) error(429, 'Zu viele Tests. Bitte warte etwas.');
const config = configFrom(await request.json().catch(() => null));
if (!config.model) error(400, 'Bitte zuerst ein Modell wählen.');
const started = Date.now();
try {
let out = '';
for await (const chunk of streamText(
config,
'Du überträgst Texte in Leichte Sprache. Antworte nur mit dem Ergebnis.',
'Übertrage in Leichte Sprache: „Aufgrund der Betriebsversammlung entfällt am Mittwoch die Frühstückspause.“'
))
out += chunk;
return json({ text: out.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 500), ms: Date.now() - started });
} catch (e) {
error(400, e instanceof AiError ? e.message : 'Der Test ist fehlgeschlagen.');
}
};

View file

@ -1,46 +0,0 @@
import { error } from '@sveltejs/kit';
import { allow } from '$lib/server/ratelimit';
import { STREAM_ERROR } from '$lib/easy-language';
import { EasyLanguageError, easyLanguageAvailable, streamEasyLanguage } from '$lib/server/easy-language';
export const POST = async ({ request, locals }) => {
if (!easyLanguageAvailable()) error(503, 'Die KI-Funktion ist nicht eingerichtet (ANTHROPIC_API_KEY fehlt).');
if (!allow(`ki-leichte-sprache:${locals.user!.id}`, 30, 3600e3)) error(429, 'Zu viele Anfragen. Bitte warte etwas.');
const body = await request.json().catch(() => null);
const title = typeof body?.title === 'string' ? body.title.slice(0, 300) : '';
const html = typeof body?.html === 'string' ? body.html : '';
const generator = streamEasyLanguage({ title, html }, request.signal);
// Ersten Abschnitt abwarten, damit Eingabefehler als normaler Fehler-Status ankommen
let first: IteratorResult<string>;
try {
first = await generator.next();
} catch (e) {
if (e instanceof EasyLanguageError) error(400, e.message);
throw e;
}
const encoder = new TextEncoder();
const stream = new ReadableStream<Uint8Array>({
async start(controller) {
try {
if (!first.done) controller.enqueue(encoder.encode(first.value));
for await (const chunk of generator) controller.enqueue(encoder.encode(chunk));
} catch (e) {
const message = e instanceof EasyLanguageError ? e.message : 'Unerwarteter Fehler bei der KI.';
if (!(e instanceof EasyLanguageError)) console.error('[leichte-sprache]', e);
controller.enqueue(encoder.encode(STREAM_ERROR + message));
}
controller.close();
},
cancel() {
generator.return(undefined);
}
});
return new Response(stream, {
headers: { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store', 'X-Accel-Buffering': 'no' }
});
};

View file

@ -0,0 +1,59 @@
import { error, json } from '@sveltejs/kit';
import { and, eq, lte } from 'drizzle-orm';
import { db } from '$lib/server/db';
import { pages, posts } from '$lib/server/db/schema';
import { AiError } from '$lib/server/ai';
import { generate, isFresh, needsAuto, type EasyKind } from '$lib/server/easy-auto';
import { allow } from '$lib/server/ratelimit';
import { STREAM_ERROR } from '$lib/easy-language';
/** Veröffentlichten Text anhand der Adresse finden */
function find(kind: EasyKind, slug: string) {
if (kind === 'post')
return db
.select()
.from(posts)
.where(and(eq(posts.slug, slug), eq(posts.published, true), lte(posts.publishedAt, new Date())))
.get();
return db.select().from(pages).where(and(eq(pages.slug, slug), eq(pages.published, true))).get();
}
/**
* Leichte Sprache für Leser: vorhandene Fassung sofort, sonst live übertragen
* (Text wird gestreamt und für alle weiteren Leser gespeichert).
*/
export const POST = async ({ request, getClientAddress }) => {
const body = await request.json().catch(() => null);
const kind: EasyKind = body?.typ === 'page' ? 'page' : 'post';
const slug = typeof body?.slug === 'string' ? body.slug.slice(0, 200) : '';
const row = find(kind, slug);
if (!row) error(404, 'Text nicht gefunden.');
if (row.contentEasy.trim()) return json({ html: row.contentEasy, auto: false });
if (isFresh(row)) return json({ html: row.contentEasyAuto, auto: true });
if (!needsAuto(row)) error(503, 'Leichte Sprache ist für diesen Text gerade nicht verfügbar.');
// Kostenschutz: pro Gerät höchstens 20 neue Übertragungen pro Stunde
if (!allow(`ki-ip:${getClientAddress()}`, 20, 3600e3)) error(429, 'Bitte versuche es etwas später noch einmal.');
const encoder = new TextEncoder();
const stream = new ReadableStream<Uint8Array>({
async start(controller) {
try {
// Läuft schon eine Übertragung (anderer Leser, Hintergrund), wird gewartet und das Ergebnis geschickt
let streamed = false;
const html = await generate(kind, row.id, (chunk) => {
streamed = true;
controller.enqueue(encoder.encode(chunk));
});
if (!streamed) controller.enqueue(encoder.encode(html));
} catch (e) {
const message = e instanceof AiError ? e.message : 'Leichte Sprache ist gerade nicht verfügbar.';
controller.enqueue(encoder.encode(STREAM_ERROR + message));
}
controller.close();
}
});
return new Response(stream, {
headers: { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store', 'X-Accel-Buffering': 'no' }
});
};