werkstaetten-app/src/lib/server/ai.ts
Friederich Loheide c20f3a73d0 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>
2026-10-03 05:49:18 +00:00

159 lines
5.6 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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.');
}