proof-of-work/proof-of-work/app/api/ai/test/route.ts

import { NextResponse } from 'next/server';
import { getCurrentUser } from '@/lib/auth';
import { prisma } from '@/lib/prisma';
import { getProvider } from '@/lib/ai/providers';

/**
 * POST /api/ai/test
 *
 * Sends a tiny "say hi in 3 words" prompt to the user's currently
 * configured AI provider and reports success/failure inline. Lets
 * the operator validate provider/model/key/baseUrl without going
 * through a full program generation.
 *
 * Returns:
 *   { ok: true, sample: "Hello there friend", tokensIn?, tokensOut?, ms }
 *   { ok: false, error: "..." }
 *
 * Times out after 30s — long enough for cold Ollama starts, short
 * enough that a hung connection doesn't hang the UI.
 */

const TEST_TIMEOUT_MS = 30_000;

export async function POST() {
  const user = await getCurrentUser();
  if (!user) {
    return NextResponse.json({ ok: false, error: 'Unauthorized' }, { status: 401 });
  }

  const prefs = await prisma.userPreferences.findUnique({
    where: { userId: user.id },
    select: { aiProvider: true, aiModel: true, aiBaseUrl: true, aiApiKey: true },
  });
  if (!prefs?.aiProvider || !prefs?.aiModel) {
    return NextResponse.json(
      {
        ok: false,
        error: 'Pick a provider + model in Settings → AI integration first.',
      },
      { status: 400 },
    );
  }
  const provider = getProvider(prefs.aiProvider);
  if (!provider) {
    return NextResponse.json(
      { ok: false, error: `Unknown provider: ${prefs.aiProvider}` },
      { status: 400 },
    );
  }

  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), TEST_TIMEOUT_MS);
  const t0 = Date.now();

  let sample = '';
  let tokensIn: number | undefined;
  let tokensOut: number | undefined;
  let providerError: string | null = null;

  try {
    for await (const chunk of provider.generate({
      apiKey: prefs.aiApiKey,
      baseUrl: prefs.aiBaseUrl,
      model: prefs.aiModel,
      systemPrompt:
        'You are a connectivity test. Reply with exactly three words: "Hello there friend." Nothing else.',
      userPrompt: 'Say hi.',
      signal: controller.signal,
    })) {
      if (chunk.type === 'text') sample += chunk.delta;
      else if (chunk.type === 'usage') {
        tokensIn = chunk.tokensIn;
        tokensOut = chunk.tokensOut;
      } else if (chunk.type === 'error') {
        providerError = chunk.message;
      }
    }
  } catch (e) {
    providerError =
      controller.signal.aborted
        ? `Timed out after ${Math.round(TEST_TIMEOUT_MS / 1000)}s`
        : (e as Error).message;
  } finally {
    clearTimeout(timer);
  }

  const ms = Date.now() - t0;

  if (providerError) {
    return NextResponse.json({ ok: false, error: providerError, ms }, { status: 200 });
  }
  if (!sample.trim()) {
    return NextResponse.json(
      {
        ok: false,
        error:
          'Got an empty response. The model returned successfully but with no text — check the model name and try again.',
        ms,
      },
      { status: 200 },
    );
  }
  return NextResponse.json({
    ok: true,
    sample: sample.trim().slice(0, 200),
    tokensIn,
    tokensOut,
    ms,
  });
}