feat(ia): chamada direta ao Gemini sem proxy serverless

Substitui a arquitetura de proxy Edge Function por chamada direta à API
do Gemini usando VITE_GEMINI_API_KEY no frontend, eliminando a dependência
de deploy no Vercel com variáveis de ambiente configuradas.

Troca o modelo gemini-2.5-flash (preview) por gemini-2.0-flash (estável,
free tier amplo) para maior confiabilidade em produção.

https://claude.ai/code/session_01JDAWxihXtB2PVp42vxvRQ8

Author: claude

.env.example

@@ -1,4 +1,4 @@
-# URL pública do proxy serverless que encapsula a Gemini API.
-# A GEMINI_API_KEY NUNCA deve ser colocada no frontend — ela vive apenas
-# nas variáveis de ambiente do provedor serverless (Vercel/Netlify/Cloudflare).
-VITE_GEMINI_PROXY_URL=https://your-proxy.vercel.app/api/gemini
+# Chave da API do Google Gemini (obtenha em https://aistudio.google.com/app/apikey)
+# Atenção: esta chave fica exposta no bundle do frontend — use apenas para testes
+# ou proteja com restrições de domínio no Google AI Studio.
+VITE_GEMINI_API_KEY=sua_chave_aqui

src/services/geminiService.ts

@@ -23,82 +23,78 @@ const ACTION_CONTEXT: Record<AiAction, string> = {
     'Verifique possíveis erros de sintaxe, parênteses órfãos ou vírgulas ausentes e conserte-os.',
 };
 
+const MODEL = 'gemini-2.0-flash';
 const TIMEOUT_MS = 15_000;
 
-export interface RunAiActionOptions {
-  action: AiAction;
-  code: string;
-  history?: { role: 'user' | 'model'; text: string }[];
-  signal?: AbortSignal;
-}
-
-export async function runAiAction(opts: RunAiActionOptions): Promise<string> {
-  const { action, code, history, signal: externalSignal } = opts;
+export async function runAiAction(opts: { action: AiAction; code: string }): Promise<string> {
+  const { action, code } = opts;
 
   if (!code.trim()) {
     throw { kind: 'empty' } satisfies AiError;
   }
 
-  const proxyUrl = (import.meta.env.VITE_GEMINI_PROXY_URL as string | undefined) ?? '/api/gemini';
+  const apiKey = import.meta.env.VITE_GEMINI_API_KEY as string | undefined;
+  if (!apiKey) {
+    throw { kind: 'config' } satisfies AiError;
+  }
+
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${MODEL}:generateContent?key=${apiKey}`;
 
   const controller = new AbortController();
   const timeoutId = window.setTimeout(() => controller.abort(), TIMEOUT_MS);
-  if (externalSignal) {
-    if (externalSignal.aborted) controller.abort();
-    else externalSignal.addEventListener('abort', () => controller.abort(), { once: true });
-  }
 
   let response: Response;
   try {
-    response = await fetch(proxyUrl, {
+    response = await fetch(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        action,
-        code,
-        history: history ?? [],
-        systemInstruction: promptText,
-        actionContext: ACTION_CONTEXT[action],
-        model: 'gemini-2.5-flash',
+        systemInstruction: { parts: [{ text: promptText }] },
+        contents: [
+          {
+            role: 'user',
+            parts: [{ text: `${ACTION_CONTEXT[action]}\n\nCódigo:\n${code}` }],
+          },
+        ],
       }),
       signal: controller.signal,
     });
   } catch (err) {
     window.clearTimeout(timeoutId);
-    if ((err as Error)?.name === 'AbortError') {
-      throw { kind: 'network' } satisfies AiError;
-    }
     throw { kind: 'network' } satisfies AiError;
   }
   window.clearTimeout(timeoutId);
 
   if (!response.ok) {
     const status = response.status;
     if (status === 429) {
-      const scope = response.headers.get('x-quota-scope');
-      if (scope === 'daily') throw { kind: 'rate_daily' } satisfies AiError;
-      throw { kind: 'rate_minute' } satisfies AiError;
+      let errorText = '';
+      try { errorText = await response.text(); } catch { /* ignore */ }
+      const scope = /per day|daily/i.test(errorText) ? 'rate_daily' : 'rate_minute';
+      throw { kind: scope } satisfies AiError;
     }
     if (status === 401 || status === 403) {
       throw { kind: 'auth' } satisfies AiError;
     }
     let message = `HTTP ${status}`;
     try {
       const body = await response.json();
-      if (body?.error) message = String(body.error);
-    } catch {
-      /* ignore */
-    }
+      if (body?.error?.message) message = String(body.error.message);
+    } catch { /* ignore */ }
     throw { kind: 'unknown', message } satisfies AiError;
   }
 
-  let payload: { text?: string };
+  let data: { candidates?: { content?: { parts?: { text?: string }[] } }[] };
   try {
-    payload = await response.json();
+    data = await response.json();
   } catch {
-    throw { kind: 'unknown', message: 'Resposta inválida do servidor.' } satisfies AiError;
+    throw { kind: 'unknown', message: 'Resposta inválida da API.' } satisfies AiError;
   }
 
-  const raw = payload.text ?? '';
+  const raw =
+    data?.candidates?.[0]?.content?.parts
+      ?.map((p) => p.text ?? '')
+      .join('') ?? '';
+
   return stripCodeFences(raw);
 }