@flowselections/ai-authenticatie 1.0.2

package/dist-lib/lib/aiCredentialTest.functions.js

@@ -0,0 +1,714 @@
+import { createServerFn } from '@tanstack/react-start';
+import { requireSupabaseAuth } from '../integrations/supabase/auth-middleware';
+const TIMEOUT_MS = 10000;
+const GEMINI_DEFAULT_API_BASE = 'https://generativelanguage.googleapis.com/v1beta';
+function withTimeout(ms = TIMEOUT_MS) {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), ms);
+    return { signal: ctrl.signal, done: () => clearTimeout(t) };
+}
+function safeParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Gemini ──────────────────────────────────────────────────────────
+// Alleen echte chat-/tekstmodellen: het model MOET generateContent ondersteunen.
+const GEMINI_GENERATE_METHODS = ['generateContent'];
+// Modellen die wel generateContent melden maar geen bruikbare chat leveren
+// (beeld, spraak, live/bidi, robotics, embeddings, ...).
+const GEMINI_EXCLUDE_TOKENS = [
+    '-image', 'image-', 'imagen', 'veo', '-tts', 'tts-', 'native-audio', 'audio',
+    '-live', 'live-', 'robotics', 'embedding', 'aqa', 'computer-use',
+];
+function isGeminiChatModel(slug) {
+    const s = slug.toLowerCase();
+    if (GEMINI_EXCLUDE_TOKENS.some(t => s.includes(t)))
+        return false;
+    return s.startsWith('gemini-') || s.startsWith('gemma-');
+}
+function normalizeGeminiApiBase(baseUrl) {
+    const raw = (baseUrl || GEMINI_DEFAULT_API_BASE).trim().replace(/\/+$/, '');
+    if (!raw)
+        return GEMINI_DEFAULT_API_BASE;
+    try {
+        const url = new URL(raw);
+        const parts = url.pathname.split('/').filter(Boolean);
+        const versionIndex = parts.findIndex(part => /^v\d+(alpha|beta)?$/i.test(part));
+        const version = versionIndex >= 0 ? parts[versionIndex] : 'v1beta';
+        url.pathname = `/${version}`;
+        url.search = '';
+        url.hash = '';
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        return GEMINI_DEFAULT_API_BASE;
+    }
+}
+function geminiModelsUrl(baseUrl, pageToken) {
+    const qs = new URLSearchParams({ pageSize: '200' });
+    if (pageToken)
+        qs.set('pageToken', pageToken);
+    return `${normalizeGeminiApiBase(baseUrl)}/models?${qs.toString()}`;
+}
+function geminiGenerateUrl(baseUrl, model) {
+    return `${normalizeGeminiApiBase(baseUrl)}/models/${encodeURIComponent(model)}:generateContent`;
+}
+function googleContextDetails(context) {
+    return [
+        context.endpoint ? `endpoint: ${context.endpoint}` : null,
+        context.model ? `model: ${context.model}` : null,
+        context.url ? `url: ${context.url}` : null,
+    ].filter(Boolean).join(', ');
+}
+function parseGoogleError(status, text, context = {}) {
+    const json = safeParse(text);
+    const msg = json?.error?.message;
+    const st = json?.error?.status;
+    const details = googleContextDetails(context);
+    if (msg) {
+        const base = st ? `${st}: ${msg}` : msg;
+        return status === 404 && details ? `${base} (${details})` : base;
+    }
+    if (status === 401 || status === 403)
+        return 'Google weigert de API-key. Controleer of de key geldig is en de Generative Language API is ingeschakeld.';
+    if (status === 429)
+        return 'Google rate-limit bereikt (429).';
+    if (status === 404) {
+        return `Google gaf 404 terug${details ? ` (${details})` : ''}. Controleer of de Gemini provider-base-url naar generativelanguage.googleapis.com wijst, of de Generative Language API is ingeschakeld en of de API-key toegang heeft tot dit endpoint/model.`;
+    }
+    return `Onverwachte fout van Google (${status}).`;
+}
+async function fetchGeminiModelsPage(apiKey, baseUrl, pageToken) {
+    const primaryUrl = geminiModelsUrl(baseUrl, pageToken);
+    const fallbackUrl = geminiModelsUrl(GEMINI_DEFAULT_API_BASE, pageToken);
+    const urls = primaryUrl === fallbackUrl ? [primaryUrl] : [primaryUrl, fallbackUrl];
+    for (const url of urls) {
+        const { signal, done } = withTimeout();
+        try {
+            const res = await fetch(url, { headers: { 'x-goog-api-key': apiKey }, signal });
+            const text = await res.text();
+            if (res.ok)
+                return { ok: true, status: res.status, text };
+            const message = parseGoogleError(res.status, text, { endpoint: 'models.list', url });
+            if (res.status !== 404 || url === urls[urls.length - 1])
+                return { ok: false, status: res.status, message };
+        }
+        catch (e) {
+            const msg = e instanceof Error && e.name === 'AbortError'
+                ? 'Timeout: Google reageerde niet binnen 10s.'
+                : `Netwerkfout: ${e instanceof Error ? e.message : 'onbekend'}`;
+            return { ok: false, status: 0, message: msg };
+        }
+        finally {
+            done();
+        }
+    }
+    return { ok: false, status: 404, message: 'Google gaf 404 terug bij het ophalen van modellen.' };
+}
+async function fetchGeminiModels(apiKey, baseUrl) {
+    const collected = [];
+    let pageToken = undefined;
+    let lastStatus = 0;
+    for (let page = 0; page < 5; page++) {
+        const pageRes = await fetchGeminiModelsPage(apiKey, baseUrl, pageToken);
+        lastStatus = pageRes.status;
+        if (!pageRes.ok)
+            return { ok: false, status: pageRes.status, message: pageRes.message };
+        const json = safeParse(pageRes.text);
+        const raw = Array.isArray(json?.models) ? json.models : [];
+        for (const m of raw) {
+            const methods = Array.isArray(m?.supportedGenerationMethods) ? m.supportedGenerationMethods : [];
+            if (!methods.some(x => GEMINI_GENERATE_METHODS.includes(x)))
+                continue;
+            const fullName = typeof m.name === 'string' ? m.name : '';
+            const slug = fullName.startsWith('models/') ? fullName.slice(7) : fullName;
+            if (!slug)
+                continue;
+            if (!isGeminiChatModel(slug))
+                continue;
+            collected.push({
+                slug,
+                display_name: typeof m.displayName === 'string' && m.displayName ? m.displayName : slug,
+                context_window: typeof m.inputTokenLimit === 'number' ? m.inputTokenLimit : null,
+                methods,
+            });
+        }
+        pageToken = typeof json?.nextPageToken === 'string' && json.nextPageToken ? json.nextPageToken : undefined;
+        if (!pageToken)
+            break;
+    }
+    return { ok: true, status: lastStatus || 200, models: collected };
+}
+async function verifyGeminiGenerate(apiKey, baseUrl, models) {
+    const capable = models.filter(m => Array.isArray(m.methods) && m.methods.includes('generateContent'));
+    if (capable.length === 0) {
+        return { ok: true, skipped: true, message: `Modellen opgehaald (${models.length}), maar geen enkel model op deze key ondersteunt generateContent — verificatie overgeslagen.` };
+    }
+    const preferred = ['gemini-3.5-flash', 'gemini-3-flash-preview', 'gemini-2.5-flash', 'gemini-2.0-flash', 'gemini-1.5-flash'];
+    const slugs = capable.map(m => m.slug);
+    const chosen = preferred.find(p => slugs.includes(p))
+        ?? slugs.find(s => s.includes('flash'))
+        ?? slugs.find(s => s.startsWith('gemini-'))
+        ?? slugs[0];
+    const url = geminiGenerateUrl(baseUrl, chosen);
+    const { signal, done } = withTimeout();
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'x-goog-api-key': apiKey, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                contents: [{ parts: [{ text: 'ping' }] }],
+                generationConfig: { maxOutputTokens: 1 },
+            }),
+            signal,
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            const parsed = parseGoogleError(res.status, text, { endpoint: 'models.generateContent', model: chosen, url });
+            const hint = `generateContent (${chosen}) → ${parsed}`;
+            return { ok: false, status: res.status, message: hint };
+        }
+        return { ok: true };
+    }
+    catch (e) {
+        const msg = e instanceof Error && e.name === 'AbortError'
+            ? 'Timeout: Google reageerde niet binnen 10s tijdens generateContent-check.'
+            : `Netwerkfout tijdens generateContent-check: ${e instanceof Error ? e.message : 'onbekend'}`;
+        return { ok: false, status: 0, message: msg };
+    }
+    finally {
+        done();
+    }
+}
+/**
+ * Google's ListModels geeft ook modellen terug die voor déze key zijn
+ * uitgefaseerd ("no longer available to new users"). Alleen een echte
+ * generateContent-aanroep laat dat zien. We pingen daarom elk model met
+ * maxOutputTokens=1 en gooien alleen 404-modellen weg. 429/503/400 zijn
+ * tijdelijk of inputgerelateerd → model blijft behouden.
+ */
+async function probeGeminiAvailability(apiKey, baseUrl, models) {
+    const CONCURRENCY = 5;
+    const unavailable = new Set();
+    const queue = [...models];
+    const worker = async () => {
+        for (;;) {
+            const m = queue.shift();
+            if (!m)
+                return;
+            const { signal, done } = withTimeout(15000);
+            try {
+                const res = await fetch(geminiGenerateUrl(baseUrl, m.slug), {
+                    method: 'POST',
+                    headers: { 'x-goog-api-key': apiKey, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        contents: [{ parts: [{ text: 'ping' }] }],
+                        generationConfig: { maxOutputTokens: 1 },
+                    }),
+                    signal,
+                });
+                if (res.status === 404)
+                    unavailable.add(m.slug);
+            }
+            catch {
+                // Netwerkfout/timeout: model niet uitsluiten.
+            }
+            finally {
+                done();
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, models.length) }, worker));
+    const usable = models.filter(m => !unavailable.has(m.slug));
+    return usable.length > 0 ? usable : models;
+}
+// ─── OpenAI ──────────────────────────────────────────────────────────
+const OPENAI_DEFAULT_API_BASE = 'https://api.openai.com/v1';
+const OPENAI_CHAT_PREFIXES = ['gpt-', 'chatgpt-', 'o1', 'o3', 'o4'];
+const OPENAI_EXCLUDE_TOKENS = [
+    'whisper', 'tts', 'audio', 'realtime', 'transcribe',
+    'dall-e', 'image', 'embedding', 'moderation',
+    'davinci', 'babbage', 'search', 'similarity', 'edit',
+];
+const OPENAI_PREFERRED_MODELS = [
+    'gpt-5-nano', 'gpt-5-mini', 'gpt-5.4-nano', 'gpt-5.4-mini',
+    'gpt-4o-mini', 'gpt-4.1-nano', 'gpt-4.1-mini', 'gpt-4o',
+];
+function normalizeOpenAIApiBase(baseUrl) {
+    const raw = (baseUrl || OPENAI_DEFAULT_API_BASE).trim().replace(/\/+$/, '');
+    if (!raw)
+        return OPENAI_DEFAULT_API_BASE;
+    try {
+        const url = new URL(raw);
+        const parts = url.pathname.split('/').filter(Boolean);
+        const versionIndex = parts.findIndex(p => /^v\d+$/i.test(p));
+        const version = versionIndex >= 0 ? parts[versionIndex] : 'v1';
+        url.pathname = `/${version}`;
+        url.search = '';
+        url.hash = '';
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        return OPENAI_DEFAULT_API_BASE;
+    }
+}
+function openAIModelsUrl(baseUrl) {
+    return `${normalizeOpenAIApiBase(baseUrl)}/models`;
+}
+function openAIChatUrl(baseUrl) {
+    return `${normalizeOpenAIApiBase(baseUrl)}/chat/completions`;
+}
+function openAIContextDetails(ctx) {
+    return [
+        ctx.endpoint ? `endpoint: ${ctx.endpoint}` : null,
+        ctx.model ? `model: ${ctx.model}` : null,
+        ctx.url ? `url: ${ctx.url}` : null,
+    ].filter(Boolean).join(', ');
+}
+function parseOpenAIError(status, text, ctx = {}) {
+    const json = safeParse(text);
+    const msg = json?.error?.message;
+    const code = json?.error?.code || json?.error?.type;
+    const details = openAIContextDetails(ctx);
+    if (msg) {
+        const base = code ? `${code}: ${msg}` : msg;
+        return details ? `${base} (${details})` : base;
+    }
+    if (status === 401)
+        return 'OpenAI weigert de API-key (401). Controleer of de key geldig is.';
+    if (status === 403)
+        return 'OpenAI weigert toegang (403). De key heeft mogelijk geen toegang tot dit endpoint of de organization/project header ontbreekt.';
+    if (status === 404)
+        return `OpenAI gaf 404 terug${details ? ` (${details})` : ''}. Controleer de base URL, of het model bestaat voor deze key.`;
+    if (status === 429)
+        return 'OpenAI rate-limit of credits op (429). Wacht even of controleer je billing.';
+    if (status >= 500)
+        return `OpenAI upstream fout (${status}). Probeer het later opnieuw.`;
+    return `Onverwachte fout van OpenAI (${status}).`;
+}
+function isOpenAIChatModel(slug) {
+    const s = slug.toLowerCase();
+    if (OPENAI_EXCLUDE_TOKENS.some(t => s.includes(t)))
+        return false;
+    return OPENAI_CHAT_PREFIXES.some(p => s.startsWith(p));
+}
+async function fetchOpenAIModelsRequest(apiKey, url) {
+    const { signal, done } = withTimeout();
+    try {
+        const res = await fetch(url, { headers: { Authorization: `Bearer ${apiKey}` }, signal });
+        const text = await res.text();
+        if (!res.ok)
+            return { ok: false, status: res.status, message: parseOpenAIError(res.status, text, { endpoint: 'models.list', url }) };
+        return { ok: true, status: res.status, text };
+    }
+    catch (e) {
+        const msg = e instanceof Error && e.name === 'AbortError'
+            ? 'Timeout: OpenAI reageerde niet binnen 10s.'
+            : `Netwerkfout: ${e instanceof Error ? e.message : 'onbekend'}`;
+        return { ok: false, status: 0, message: msg };
+    }
+    finally {
+        done();
+    }
+}
+async function fetchOpenAIModels(apiKey, baseUrl) {
+    const primaryUrl = openAIModelsUrl(baseUrl);
+    const fallbackUrl = openAIModelsUrl(OPENAI_DEFAULT_API_BASE);
+    const urls = primaryUrl === fallbackUrl ? [primaryUrl] : [primaryUrl, fallbackUrl];
+    let last = null;
+    for (const url of urls) {
+        const res = await fetchOpenAIModelsRequest(apiKey, url);
+        if (res.ok) {
+            const json = safeParse(res.text);
+            const raw = Array.isArray(json?.data) ? json.data : [];
+            const models = raw
+                .map((m) => {
+                if (typeof m?.id !== 'string' || !m.id)
+                    return null;
+                if (!isOpenAIChatModel(m.id))
+                    return null;
+                return { slug: m.id, display_name: m.id, context_window: null, methods: ['chat.completions'] };
+            })
+                .filter((m) => m !== null);
+            return { ok: true, status: res.status, models };
+        }
+        last = { status: res.status, message: res.message };
+        if (res.status !== 404)
+            break;
+    }
+    return { ok: false, status: last?.status ?? 0, message: last?.message ?? 'OpenAI: onbekende fout.' };
+}
+async function verifyOpenAIChat(apiKey, baseUrl, models) {
+    const slugs = models.map(m => m.slug);
+    if (slugs.length === 0) {
+        return { ok: true, skipped: true, message: 'Modellen opgehaald, maar geen chat-model beschikbaar voor deze key — verificatie overgeslagen.' };
+    }
+    const chosen = OPENAI_PREFERRED_MODELS.find(p => slugs.includes(p))
+        ?? slugs.find(s => s.startsWith('gpt-4o-mini'))
+        ?? slugs.find(s => s.startsWith('gpt-'))
+        ?? slugs[0];
+    const url = openAIChatUrl(baseUrl);
+    const { signal, done } = withTimeout();
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: chosen,
+                messages: [{ role: 'user', content: 'ping' }],
+                max_completion_tokens: 1,
+            }),
+            signal,
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            const parsed = parseOpenAIError(res.status, text, { endpoint: 'chat.completions', model: chosen, url });
+            return { ok: false, status: res.status, message: `chat/completions (${chosen}) → ${parsed}` };
+        }
+        return { ok: true };
+    }
+    catch (e) {
+        const msg = e instanceof Error && e.name === 'AbortError'
+            ? 'Timeout: OpenAI reageerde niet binnen 10s tijdens chat-check.'
+            : `Netwerkfout tijdens chat-check: ${e instanceof Error ? e.message : 'onbekend'}`;
+        return { ok: false, status: 0, message: msg };
+    }
+    finally {
+        done();
+    }
+}
+// ─── Anthropic ───────────────────────────────────────────────────────
+const ANTHROPIC_DEFAULT_API_BASE = 'https://api.anthropic.com';
+const ANTHROPIC_VERSION = '2023-06-01';
+const ANTHROPIC_EXCLUDE_TOKENS = ['instant', 'embedding'];
+const ANTHROPIC_LEGACY_PREFIXES = ['claude-1', 'claude-2'];
+const ANTHROPIC_PREFERRED_MODELS = [
+    'claude-haiku-4-5',
+    'claude-3-5-haiku-latest',
+    'claude-3-5-haiku-20241022',
+    'claude-3-haiku-20240307',
+    'claude-sonnet-4-5',
+    'claude-3-5-sonnet-latest',
+];
+function normalizeAnthropicApiBase(baseUrl) {
+    const raw = (baseUrl || ANTHROPIC_DEFAULT_API_BASE).trim().replace(/\/+$/, '');
+    if (!raw)
+        return ANTHROPIC_DEFAULT_API_BASE;
+    try {
+        const url = new URL(raw);
+        url.pathname = '/';
+        url.search = '';
+        url.hash = '';
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        return ANTHROPIC_DEFAULT_API_BASE;
+    }
+}
+function anthropicContextDetails(ctx) {
+    return [
+        ctx.endpoint ? `endpoint: ${ctx.endpoint}` : null,
+        ctx.model ? `model: ${ctx.model}` : null,
+        ctx.url ? `url: ${ctx.url}` : null,
+    ].filter(Boolean).join(', ');
+}
+function parseAnthropicError(status, text, ctx = {}) {
+    const json = safeParse(text);
+    const msg = json?.error?.message;
+    const type = json?.error?.type;
+    const details = anthropicContextDetails(ctx);
+    if (msg) {
+        const base = type ? `${type}: ${msg}` : msg;
+        return details ? `${base} (${details})` : base;
+    }
+    if (status === 401)
+        return 'Anthropic weigert de API-key (401). Controleer of de key geldig is.';
+    if (status === 403)
+        return 'Anthropic weigert toegang (403). De key heeft geen rechten voor dit endpoint of workspace.';
+    if (status === 404)
+        return `Anthropic gaf 404 terug${details ? ` (${details})` : ''}. Controleer de base URL en of het model beschikbaar is voor deze key.`;
+    if (status === 429)
+        return 'Anthropic rate-limit of credits op (429). Wacht even of controleer je billing.';
+    if (status >= 500)
+        return `Anthropic upstream fout (${status}). Probeer het later opnieuw.`;
+    return `Onverwachte fout van Anthropic (${status}).`;
+}
+function isAnthropicChatModel(slug) {
+    const s = slug.toLowerCase();
+    if (!s.startsWith('claude-'))
+        return false;
+    if (ANTHROPIC_EXCLUDE_TOKENS.some(t => s.includes(t)))
+        return false;
+    if (ANTHROPIC_LEGACY_PREFIXES.some(p => s.startsWith(p)))
+        return false;
+    return true;
+}
+function anthropicModelsUrl(baseUrl, afterId) {
+    const qs = new URLSearchParams({ limit: '1000' });
+    if (afterId)
+        qs.set('after_id', afterId);
+    return `${normalizeAnthropicApiBase(baseUrl)}/v1/models?${qs.toString()}`;
+}
+function anthropicMessagesUrl(baseUrl) {
+    return `${normalizeAnthropicApiBase(baseUrl)}/v1/messages`;
+}
+async function fetchAnthropicModelsPage(apiKey, url) {
+    const { signal, done } = withTimeout();
+    try {
+        const res = await fetch(url, {
+            headers: { 'x-api-key': apiKey, 'anthropic-version': ANTHROPIC_VERSION },
+            signal,
+        });
+        const text = await res.text();
+        if (!res.ok)
+            return { ok: false, status: res.status, message: parseAnthropicError(res.status, text, { endpoint: 'models.list', url }) };
+        return { ok: true, status: res.status, text };
+    }
+    catch (e) {
+        const msg = e instanceof Error && e.name === 'AbortError'
+            ? 'Timeout: Anthropic reageerde niet binnen 10s.'
+            : `Netwerkfout: ${e instanceof Error ? e.message : 'onbekend'}`;
+        return { ok: false, status: 0, message: msg };
+    }
+    finally {
+        done();
+    }
+}
+async function fetchAnthropicModels(apiKey, baseUrl) {
+    const collected = [];
+    let afterId = undefined;
+    let lastStatus = 0;
+    for (let page = 0; page < 5; page++) {
+        const primaryUrl = anthropicModelsUrl(baseUrl, afterId);
+        const fallbackUrl = anthropicModelsUrl(ANTHROPIC_DEFAULT_API_BASE, afterId);
+        const urls = primaryUrl === fallbackUrl ? [primaryUrl] : [primaryUrl, fallbackUrl];
+        let pageRes = null;
+        for (const url of urls) {
+            const attempt = await fetchAnthropicModelsPage(apiKey, url);
+            pageRes = attempt;
+            if (attempt.ok)
+                break;
+            if (attempt.status !== 404)
+                break;
+        }
+        if (!pageRes)
+            return { ok: false, status: 0, message: 'Anthropic: onbekende fout.' };
+        if (!pageRes.ok)
+            return { ok: false, status: pageRes.status, message: pageRes.message };
+        lastStatus = pageRes.status;
+        const json = safeParse(pageRes.text);
+        const raw = Array.isArray(json?.data) ? json.data : [];
+        for (const m of raw) {
+            if (typeof m?.id !== 'string' || !m.id)
+                continue;
+            if (!isAnthropicChatModel(m.id))
+                continue;
+            collected.push({
+                slug: m.id,
+                display_name: typeof m.display_name === 'string' && m.display_name ? m.display_name : m.id,
+                context_window: null,
+                methods: ['messages'],
+            });
+        }
+        if (!json?.has_more || !json.last_id)
+            break;
+        afterId = json.last_id;
+    }
+    return { ok: true, status: lastStatus || 200, models: collected };
+}
+async function verifyAnthropicMessage(apiKey, baseUrl, models) {
+    const slugs = models.map(m => m.slug);
+    if (slugs.length === 0) {
+        return { ok: true, skipped: true, message: 'Modellen opgehaald, maar geen chat-model beschikbaar voor deze key — verificatie overgeslagen.' };
+    }
+    const chosen = ANTHROPIC_PREFERRED_MODELS.find(p => slugs.includes(p))
+        ?? slugs.find(s => s.includes('haiku'))
+        ?? slugs.find(s => s.startsWith('claude-'))
+        ?? slugs[0];
+    const url = anthropicMessagesUrl(baseUrl);
+    const { signal, done } = withTimeout();
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': ANTHROPIC_VERSION,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: chosen,
+                max_tokens: 1,
+                messages: [{ role: 'user', content: 'ping' }],
+            }),
+            signal,
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            const parsed = parseAnthropicError(res.status, text, { endpoint: 'messages', model: chosen, url });
+            return { ok: false, status: res.status, message: `messages (${chosen}) → ${parsed}` };
+        }
+        return { ok: true };
+    }
+    catch (e) {
+        const msg = e instanceof Error && e.name === 'AbortError'
+            ? 'Timeout: Anthropic reageerde niet binnen 10s tijdens messages-check.'
+            : `Netwerkfout tijdens messages-check: ${e instanceof Error ? e.message : 'onbekend'}`;
+        return { ok: false, status: 0, message: msg };
+    }
+    finally {
+        done();
+    }
+}
+// ─── Dispatch ────────────────────────────────────────────────────────
+async function fetchModelsFor(provider, apiKey) {
+    const slug = (provider.slug || '').toLowerCase();
+    if (slug.includes('gemini') || slug.includes('google')) {
+        const res = await fetchGeminiModels(apiKey, provider.base_url);
+        if (!res.ok)
+            return res;
+        const usable = await probeGeminiAvailability(apiKey, provider.base_url, res.models);
+        return { ...res, models: usable };
+    }
+    if (slug.includes('openai') || slug.includes('gpt'))
+        return fetchOpenAIModels(apiKey, provider.base_url);
+    if (slug.includes('anthropic') || slug.includes('claude'))
+        return fetchAnthropicModels(apiKey, provider.base_url);
+    return { ok: false, status: 400, message: `Provider "${provider.name}" wordt niet ondersteund.` };
+}
+async function loadCredentialAndProvider(supabase, credentialId) {
+    const { data: cred, error: credErr } = await supabase
+        .from('ai_credentials').select('id, api_key, active, provider_id').eq('id', credentialId).maybeSingle();
+    if (credErr || !cred)
+        return { error: { ok: false, status: 404, message: 'Credential niet gevonden.' } };
+    const { data: prov, error: provErr } = await supabase
+        .from('ai_providers').select('id, slug, name, base_url').eq('id', cred.provider_id).maybeSingle();
+    if (provErr || !prov)
+        return { error: { ok: false, status: 404, message: 'Provider niet gevonden.' } };
+    return { credential: cred, provider: prov };
+}
+// Autorisatie: elke ingelogde gebruiker mag AI-credentials testen/synchroniseren.
+// Rol-check bewust verwijderd; authenticatie regelt requireSupabaseAuth.
+// ─── Server functions ────────────────────────────────────────────────
+export const testAiCredential = createServerFn({ method: 'POST' })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => {
+    const v = input;
+    if (!v || typeof v.credentialId !== 'string' || !v.credentialId)
+        throw new Error('credentialId is verplicht');
+    return { credentialId: v.credentialId };
+})
+    .handler(async ({ data, context }) => {
+    const { supabase } = context;
+    const loaded = await loadCredentialAndProvider(supabase, data.credentialId);
+    if ('error' in loaded)
+        return loaded.error;
+    const res = await fetchModelsFor(loaded.provider, loaded.credential.api_key);
+    if (!res.ok)
+        return { ok: false, status: res.status, message: res.message };
+    const providerSlug = (loaded.provider.slug || '').toLowerCase();
+    const isGemini = providerSlug.includes('gemini') || providerSlug.includes('google');
+    const isOpenAI = providerSlug.includes('openai') || providerSlug.includes('gpt');
+    const isAnthropic = providerSlug.includes('anthropic') || providerSlug.includes('claude');
+    if (isGemini) {
+        const gen = await verifyGeminiGenerate(loaded.credential.api_key, loaded.provider.base_url, res.models);
+        if (!gen.ok)
+            return { ok: false, status: gen.status, message: gen.message, sampleModels: res.models.map(m => m.slug) };
+        const skippedMsg = 'skipped' in gen ? gen.message : `Verbinding werkt. Key kan modellen listen én tekst genereren. ${res.models.length} modellen beschikbaar.`;
+        return {
+            ok: true, status: res.status,
+            message: skippedMsg,
+            sampleModels: res.models.map(m => m.slug),
+        };
+    }
+    if (isOpenAI) {
+        const gen = await verifyOpenAIChat(loaded.credential.api_key, loaded.provider.base_url, res.models);
+        if (!gen.ok)
+            return { ok: false, status: gen.status, message: gen.message, sampleModels: res.models.map(m => m.slug) };
+        const skippedMsg = 'skipped' in gen ? gen.message : `Verbinding werkt. Key kan modellen listen én chat-completions genereren. ${res.models.length} chat-modellen beschikbaar.`;
+        return {
+            ok: true, status: res.status,
+            message: skippedMsg,
+            sampleModels: res.models.map(m => m.slug),
+        };
+    }
+    if (isAnthropic) {
+        const gen = await verifyAnthropicMessage(loaded.credential.api_key, loaded.provider.base_url, res.models);
+        if (!gen.ok)
+            return { ok: false, status: gen.status, message: gen.message, sampleModels: res.models.map(m => m.slug) };
+        const skippedMsg = 'skipped' in gen ? gen.message : `Verbinding werkt. Key kan modellen listen én berichten genereren. ${res.models.length} chat-modellen beschikbaar.`;
+        return {
+            ok: true, status: res.status,
+            message: skippedMsg,
+            sampleModels: res.models.map(m => m.slug),
+        };
+    }
+    return {
+        ok: true, status: res.status,
+        message: `Verbinding werkt. ${res.models.length} modellen beschikbaar.`,
+        sampleModels: res.models.map(m => m.slug),
+    };
+});
+export const syncAiCredentialModels = createServerFn({ method: 'POST' })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => {
+    const v = input;
+    if (!v || typeof v.credentialId !== 'string' || !v.credentialId)
+        throw new Error('credentialId is verplicht');
+    return { credentialId: v.credentialId };
+})
+    .handler(async ({ data, context }) => {
+    const { supabase } = context;
+    const loaded = await loadCredentialAndProvider(supabase, data.credentialId);
+    if ('error' in loaded)
+        return { ...loaded.error, synced: 0 };
+    const res = await fetchModelsFor(loaded.provider, loaded.credential.api_key);
+    if (!res.ok)
+        return { ok: false, status: res.status, message: res.message, synced: 0 };
+    if (res.models.length === 0) {
+        return { ok: true, status: res.status, message: 'Provider gaf 0 modellen terug.', synced: 0, models: [] };
+    }
+    const rows = res.models.map(m => ({
+        provider_id: loaded.provider.id,
+        slug: m.slug,
+        display_name: m.display_name,
+        context_window: m.context_window,
+        modality: 'text',
+        active: true,
+    }));
+    const { error: upsertErr } = await supabase
+        .from('ai_models')
+        .upsert(rows, { onConflict: 'provider_id,slug', ignoreDuplicates: false });
+    if (upsertErr) {
+        return { ok: false, status: 500, message: `Opslaan mislukt: ${upsertErr.message}`, synced: 0 };
+    }
+    // Modellen die de provider niet meer teruggeeft (uitgefaseerd of niet-chat)
+    // worden op inactief gezet, zodat ze uit de keuzelijsten verdwijnen.
+    let deactivated = 0;
+    const keep = res.models.map(m => m.slug);
+    const { data: stale } = await supabase
+        .from('ai_models')
+        .select('id, slug')
+        .eq('provider_id', loaded.provider.id)
+        .eq('active', true);
+    const staleIds = (Array.isArray(stale) ? stale : [])
+        .filter((r) => !keep.includes(r.slug))
+        .map((r) => r.id);
+    if (staleIds.length > 0) {
+        const { error: deactErr } = await supabase
+            .from('ai_models').update({ active: false }).in('id', staleIds);
+        if (!deactErr)
+            deactivated = staleIds.length;
+    }
+    return {
+        ok: true, status: res.status,
+        message: deactivated > 0
+            ? `${rows.length} modellen gesynchroniseerd, ${deactivated} niet meer ondersteunde modellen uitgeschakeld.`
+            : `${rows.length} modellen gesynchroniseerd.`,
+        synced: rows.length,
+        models: rows.map(r => ({ slug: r.slug, display_name: r.display_name })),
+    };
+});