perf: memo GridCard, fuse save fns, fix slash tab active color

memento-note/app/api/user/api-keys/test-model/route.ts

@@ -0,0 +1,167 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/auth';
+import { getEffectiveTier } from '@/lib/entitlements';
+import { isByokProviderAllowed } from '@/lib/byok';
+import { VALID_PROVIDERS, type AiGatewayProvider } from '@/lib/ai/router';
+
+function cleanReply(text: string): string {
+  // Strip <think>...</think> reasoning blocks (DeepSeek, MiniMax, etc.)
+  return text.replace(/<think>[\s\S]*?<\/think>/gi, '').replace(/<thinking>[\s\S]*?<\/thinking>/gi, '').trim() || text.trim()
+}
+
+const PROVIDER_URLS: Record<string, string> = {
+  openai:     'https://api.openai.com/v1',
+  deepseek:   'https://api.deepseek.com/v1',
+  openrouter: 'https://openrouter.ai/api/v1',
+  mistral:    'https://api.mistral.ai/v1',
+  zai:        'https://api.zukijourney.com/v1',
+  minimax:    'https://api.minimax.io/v1',
+  glm:        'https://open.bigmodel.ai/api/paas/v4',
+};
+
+/**
+ * GET /api/user/api-keys/test-model?provider=X&key=Y&model=Z[&baseUrl=...]
+ * Sends a minimal chat completion to verify the key + model work end-to-end.
+ */
+export async function GET(request: NextRequest) {
+  const session = await auth();
+  if (!session?.user?.id) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+
+  const tier = await getEffectiveTier(session.user.id);
+  if (tier === 'BASIC') return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
+
+  const { searchParams } = request.nextUrl;
+  const provider = searchParams.get('provider') as AiGatewayProvider;
+  const apiKey   = searchParams.get('key') ?? '';
+  const model    = searchParams.get('model') ?? '';
+  const baseUrl  = searchParams.get('baseUrl') ?? undefined;
+
+  if (!provider || apiKey.length < 4 || !model) {
+    return NextResponse.json({ error: 'Missing parameters' }, { status: 400 });
+  }
+
+  if (!VALID_PROVIDERS.has(provider)) {
+    return NextResponse.json({ error: 'Invalid provider' }, { status: 400 });
+  }
+
+  if (!isByokProviderAllowed(tier, provider)) {
+    return NextResponse.json({ error: 'Tier restricted' }, { status: 403 });
+  }
+
+  const start = Date.now();
+
+  try {
+    // Anthropic has a different API format
+    if (provider === 'anthropic' || provider === 'anthropic_custom' || provider === 'custom_anthropic') {
+      const url = baseUrl
+        ? `${baseUrl.replace(/\/$/, '')}/messages`
+        : 'https://api.anthropic.com/v1/messages';
+
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01',
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+        model,
+        max_tokens: 60,
+        messages: [{ role: 'user', content: 'Say: ok' }],
+      }),
+        signal: AbortSignal.timeout(20_000),
+      });
+
+      const latency = Date.now() - start;
+      if (res.status === 401 || res.status === 403) {
+        return NextResponse.json({ ok: false, error: 'Clé API invalide' });
+      }
+      if (res.status === 404) {
+        return NextResponse.json({ ok: false, error: `Modèle "${model}" introuvable` });
+      }
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        return NextResponse.json({ ok: false, error: body?.error?.message ?? `Erreur ${res.status}` });
+      }
+      const body = await res.json();
+      const raw = body?.content?.[0]?.text ?? '(réponse reçue)';
+      return NextResponse.json({ ok: true, latency, reply: cleanReply(raw) });
+    }
+
+    // Google AI
+    if (provider === 'google') {
+      const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent?key=${apiKey}`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ contents: [{ parts: [{ text: 'Reply with: ok' }] }], generationConfig: { maxOutputTokens: 5 } }),
+        signal: AbortSignal.timeout(20_000),
+      });
+      const latency = Date.now() - start;
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        if (res.status === 400 && body?.error?.message?.includes('not found')) {
+          return NextResponse.json({ ok: false, error: `Modèle "${model}" introuvable` });
+        }
+        return NextResponse.json({ ok: false, error: body?.error?.message ?? `Erreur ${res.status}` });
+      }
+      const body = await res.json();
+      const raw = body?.candidates?.[0]?.content?.parts?.[0]?.text ?? '(réponse reçue)';
+      return NextResponse.json({ ok: true, latency, reply: cleanReply(raw) });
+    }
+
+    // OpenAI-compatible (openai, deepseek, minimax, openrouter, mistral, glm, zai, custom_openai, custom, lmstudio)
+    const url = (provider === 'custom' || provider === 'custom_openai')
+      ? `${(baseUrl ?? '').replace(/\/$/, '')}/chat/completions`
+      : `${PROVIDER_URLS[provider] ?? ''}/chat/completions`;
+
+    if (!url || url.startsWith('/')) {
+      return NextResponse.json({ ok: false, error: 'URL de l\'API manquante' });
+    }
+
+    const headers: Record<string, string> = {
+      'content-type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    };
+    if (provider === 'openrouter') {
+      headers['HTTP-Referer'] = 'https://memento-note.com';
+      headers['X-Title'] = 'Memento';
+    }
+
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        model,
+        max_tokens: 5,
+        messages: [{ role: 'user', content: 'Reply with: ok' }],
+      }),
+      signal: AbortSignal.timeout(20_000),
+    });
+
+    const latency = Date.now() - start;
+
+    if (res.status === 401 || res.status === 403) {
+      return NextResponse.json({ ok: false, error: 'Clé API invalide ou refusée' });
+    }
+    if (res.status === 404) {
+      return NextResponse.json({ ok: false, error: `Modèle "${model}" introuvable` });
+    }
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      const msg = body?.error?.message ?? body?.message ?? `Erreur ${res.status}`;
+      return NextResponse.json({ ok: false, error: msg });
+    }
+
+    const body = await res.json();
+    const raw = body?.choices?.[0]?.message?.content ?? '(réponse reçue)';
+    return NextResponse.json({ ok: true, latency, reply: cleanReply(raw) });
+
+  } catch (err: unknown) {
+    const latency = Date.now() - start;
+    if (err instanceof Error && err.name === 'TimeoutError') {
+      return NextResponse.json({ ok: false, error: 'Délai d\'attente dépassé (>20s)' });
+    }
+    return NextResponse.json({ ok: false, error: err instanceof Error ? err.message : 'Erreur inconnue', latency });
+  }
+}