feat: LEXAI-16 request timeout (fetchWithTimeout), LEXAI-19 Copy As, LEXAI-20 Download

entrypoints/background.ts

@@ -1,6 +1,18 @@
 import { defineBackground } from 'wxt/utils/define-background';
 import nacl from 'tweetnacl';
 
+// ─── Fetch with timeout ───────────────────────────────────────────────────────
+
+async function fetchWithTimeout(url: string, options: RequestInit, timeoutMs = 30000): Promise<Response> {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(id);
+  }
+}
+
 // ─── Types ────────────────────────────────────────────────────────────────────
 
 interface AnalyzePayload {
@@ -69,7 +81,7 @@ async function callOpenAI(payload: AnalyzePayload, config: LexAIConfig): Promise
   let res: Response;
 
   try {
-    res = await fetch('https://api.openai.com/v1/chat/completions', {
+    res = await fetchWithTimeout('https://api.openai.com/v1/chat/completions', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -106,7 +118,7 @@ async function callAnthropic(payload: AnalyzePayload, config: LexAIConfig): Prom
   let res: Response;
 
   try {
-    res = await fetch('https://api.anthropic.com/v1/messages', {
+    res = await fetchWithTimeout('https://api.anthropic.com/v1/messages', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -141,7 +153,7 @@ async function callGroq(payload: AnalyzePayload, config: LexAIConfig): Promise<L
   let res: Response;
 
   try {
-    res = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+    res = await fetchWithTimeout('https://api.groq.com/openai/v1/chat/completions', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -178,7 +190,7 @@ async function callOpenRouter(payload: AnalyzePayload, config: LexAIConfig): Pro
   let res: Response;
 
   try {
-    res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+    res = await fetchWithTimeout('https://openrouter.ai/api/v1/chat/completions', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -211,6 +223,130 @@ async function callOpenRouter(payload: AnalyzePayload, config: LexAIConfig): Pro
   return { result: result.trim() };
 }
 
+// ─── Generic provider call (used by copy-as and future features) ──────────────
+
+async function callProvider(config: LexAIConfig, text: string, systemPrompt: string): Promise<LexAIResponse> {
+  const payload: AnalyzePayload = { text, action: '__custom__' };
+  const provider = config.provider || 'openai';
+
+  switch (provider) {
+    case 'openai':     return callOpenAIWithPrompt(payload, config, systemPrompt);
+    case 'anthropic':  return callAnthropicWithPrompt(payload, config, systemPrompt);
+    case 'groq':       return callGroqWithPrompt(payload, config, systemPrompt);
+    case 'openrouter': return callOpenRouterWithPrompt(payload, config, systemPrompt);
+    default:           return { error: `Unknown provider: "${provider}". Please check LexAI settings.` };
+  }
+}
+
+async function callOpenAIWithPrompt(payload: AnalyzePayload, config: LexAIConfig, systemPrompt: string): Promise<LexAIResponse> {
+  const model = config.model || 'gpt-4o-mini';
+  let res: Response;
+  try {
+    res = await fetchWithTimeout('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.apiKey}` },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: payload.text },
+        ],
+        max_tokens: 1024,
+        temperature: 0.7,
+      }),
+    });
+  } catch (err) {
+    return { error: `Network error reaching OpenAI: ${String(err)}` };
+  }
+  const data = await res.json();
+  if (!res.ok) return { error: `OpenAI error: ${data?.error?.message ?? `HTTP ${res.status}`}` };
+  const result = data?.choices?.[0]?.message?.content as string | undefined;
+  if (!result) return { error: 'OpenAI returned an empty response.' };
+  return { result: result.trim() };
+}
+
+async function callAnthropicWithPrompt(payload: AnalyzePayload, config: LexAIConfig, systemPrompt: string): Promise<LexAIResponse> {
+  const model = config.model || 'claude-3-5-haiku-20241022';
+  let res: Response;
+  try {
+    res = await fetchWithTimeout('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'x-api-key': config.apiKey!, 'anthropic-version': '2023-06-01' },
+      body: JSON.stringify({
+        model,
+        max_tokens: 1024,
+        system: systemPrompt,
+        messages: [{ role: 'user', content: payload.text }],
+      }),
+    });
+  } catch (err) {
+    return { error: `Network error reaching Anthropic: ${String(err)}` };
+  }
+  const data = await res.json();
+  if (!res.ok) return { error: `Anthropic error: ${data?.error?.message ?? `HTTP ${res.status}`}` };
+  const result = data?.content?.[0]?.text as string | undefined;
+  if (!result) return { error: 'Anthropic returned an empty response.' };
+  return { result: result.trim() };
+}
+
+async function callGroqWithPrompt(payload: AnalyzePayload, config: LexAIConfig, systemPrompt: string): Promise<LexAIResponse> {
+  const model = config.model || 'llama-3.3-70b-versatile';
+  let res: Response;
+  try {
+    res = await fetchWithTimeout('https://api.groq.com/openai/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.apiKey}` },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: payload.text },
+        ],
+        max_tokens: 1024,
+        temperature: 0.7,
+      }),
+    });
+  } catch (err) {
+    return { error: `Network error reaching Groq: ${String(err)}` };
+  }
+  const data = await res.json();
+  if (!res.ok) return { error: `Groq error: ${data?.error?.message ?? `HTTP ${res.status}`}` };
+  const result = data?.choices?.[0]?.message?.content as string | undefined;
+  if (!result) return { error: 'Groq returned an empty response.' };
+  return { result: result.trim() };
+}
+
+async function callOpenRouterWithPrompt(payload: AnalyzePayload, config: LexAIConfig, systemPrompt: string): Promise<LexAIResponse> {
+  const model = config.model || 'openai/gpt-4o-mini';
+  let res: Response;
+  try {
+    res = await fetchWithTimeout('https://openrouter.ai/api/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${config.apiKey}`,
+        'HTTP-Referer': 'https://lexai.dev',
+        'X-Title': 'LexAI',
+      },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: payload.text },
+        ],
+        max_tokens: 1024,
+      }),
+    });
+  } catch (err) {
+    return { error: `Network error reaching OpenRouter: ${String(err)}` };
+  }
+  const data = await res.json();
+  if (!res.ok) return { error: `OpenRouter error: ${data?.error?.message ?? `HTTP ${res.status}`}` };
+  const result = data?.choices?.[0]?.message?.content as string | undefined;
+  if (!result) return { error: 'OpenRouter returned an empty response.' };
+  return { result: result.trim() };
+}
+
 // ─── Main handler ─────────────────────────────────────────────────────────────
 
 async function handleAnalyzeText(payload: AnalyzePayload): Promise<LexAIResponse> {
@@ -299,5 +435,28 @@ export default defineBackground(() => {
         .catch((err) => sendResponse({ error: String(err) }));
       return true; // Keep channel open for async response
     }
+
+    if (message.type === 'COPY_AS') {
+      const { text, format } = message as { text: string; format: string };
+      chrome.storage.local.get(['provider', 'apiKey', 'apiKeyEnc', 'encKey', 'model'])
+        .then(async (stored) => {
+          const config = stored as LexAIConfig;
+          let apiKey = config.apiKey;
+          if (config.apiKeyEnc && config.encKey) {
+            const decrypted = await decryptApiKey(config.encKey, config.apiKeyEnc);
+            if (decrypted) apiKey = decrypted;
+          }
+          if (!apiKey || apiKey.trim() === '') {
+            sendResponse({ error: 'No API key configured. Please open LexAI settings.' });
+            return;
+          }
+          const resolvedConfig: LexAIConfig = { ...config, apiKey: apiKey.trim() };
+          const systemPrompt = `Reformat the following text as ${format}. Return only the reformatted result, no explanation.`;
+          return callProvider(resolvedConfig, text, systemPrompt);
+        })
+        .then((res) => { if (res) sendResponse(res); })
+        .catch((err) => sendResponse({ error: String(err) }));
+      return true;
+    }
   });
 });