@gringow/gringow 0.1.3 → 0.2.0

package/dist/io/ask-llm.mjs

@@ -1,12 +1,9 @@
+import { igniteEngine, Message } from 'multi-llm-ts';
 import { cosmiconfig } from 'cosmiconfig';
 import merge from 'lodash.merge';
 import { z } from 'zod';
-import Anthropic from '@anthropic-ai/sdk';
-import { GoogleGenerativeAI } from '@google/generative-ai';
-import { env, pipeline } from '@huggingface/transformers';
-import 'fs';
 
-// src/config.ts
+// src/io/ask-llm.ts
 
 // src/constants/default-config.ts
 var defaultConfig = {
@@ -20,19 +17,34 @@ var defaultConfig = {
     prefix: "grw",
     write: true
   },
-  keys: {},
   sourceLanguage: "en-US",
+  defaultLanguage: "pt-BR",
   languages: ["pt-BR", "fr-CA"],
   llm: {
-    choice: "huggingface",
-    model: "Xenova/nllb-200-distilled-600M",
+    provider: "openai",
+    apiKey: void 0,
+    model: "gpt-4o-mini",
     temperature: 1,
     sleep: 0
   },
   globby: "./src/**/*.{js,jsx,ts,tsx}"
 };
 var languageSchema = z.string().regex(/^[a-z]{2,3}(-[A-Z]{2})?$/);
-var llmOptionsSchema = z.enum(["gemini", "anthropic", "huggingface"]);
+var llmProviderSchema = z.enum([
+  "anthropic",
+  "gemini",
+  "openai",
+  "groq",
+  "mistral",
+  "ollama",
+  "xai",
+  "deepseek",
+  "openrouter",
+  "cerebras",
+  "lmstudio",
+  "azure",
+  "meta"
+]);
 var configSchema = z.object({
   debug: z.boolean().optional(),
   log: z.object({
@@ -44,14 +56,13 @@ var configSchema = z.object({
     prefix: z.string(),
     write: z.boolean().optional()
   }),
-  keys: z.object({
-    anthropicApiKey: z.string().optional(),
-    geminiApiKey: z.string().optional()
-  }),
   sourceLanguage: languageSchema,
+  defaultLanguage: languageSchema,
   languages: z.array(languageSchema),
   llm: z.object({
-    choice: llmOptionsSchema,
+    provider: llmProviderSchema,
+    apiKey: z.string().optional(),
+    baseURL: z.string().optional(),
     model: z.string().nullable(),
     temperature: z.number().optional(),
     sleep: z.number().optional(),
@@ -65,17 +76,15 @@ var configSchema = z.object({
   globby: z.string().regex(/^\.\/.*/).optional()
 }).refine(
   (data) => {
-    if (data.llm.choice === "gemini" && !data.keys.geminiApiKey) {
-      return false;
+    const noApiKeyRequired = ["ollama", "lmstudio"];
+    if (noApiKeyRequired.includes(data.llm.provider)) {
+      return true;
     }
-    if (data.llm.choice === "anthropic" && !data.keys.anthropicApiKey) {
-      return false;
-    }
-    return true;
+    return !!data.llm.apiKey;
   },
   {
-    message: "The API key corresponding to the chosen LLM must be present.",
-    path: ["keys"]
+    message: "The API key must be present in llm.apiKey for the chosen provider.",
+    path: ["llm", "apiKey"]
   }
 );
 
@@ -111,7 +120,7 @@ Your task is to translate a given text and output **only one valid JSON object**
 
 Follow these rules strictly:
 
-1. The original text is written in English.
+1. The original text is written in English or Spanish.
 2. You will receive additional user parameters under the variable 'extraInstructions'. These may specify tone, persona, style, context, or any relevant translation guideline.  
    - Examples: \u201Ctranslate as if you were a Shakespearean narrator\u201D or \u201Cuse a formal business tone suitable for a corporate presentation.\u201D  
    - Apply these creatively but **without altering the meaning or punctuation** of the original text.
@@ -144,10 +153,10 @@ Translate the following text faithfully:
 function defaultPostPrompt(_config) {
   return "";
 }
-function prePrompt(config, append, replace) {
+function prePrompt(config, prepend, replace) {
   return [
     // ...(append ? ['[SPECIFIC_INPUTS]', String(append), '[/SPECIFIC_INPUTS]'] : []),
-    replace ? String(replace) : defaultPrePrompt(config, append)
+    replace ? String(replace) : defaultPrePrompt(config, prepend)
   ].join(" ").trim();
 }
 function postPrompt(config, prepend, replace) {
@@ -156,445 +165,64 @@ function postPrompt(config, prepend, replace) {
     replace ? String(replace) : defaultPostPrompt()
   ].join(" ").trim();
 }
-async function askAnthropic(prompt, prePrompt2, postPrompt2) {
-  const config = await awaitedConfig;
-  if (Number(config.llm.sleep)) {
-    await new Promise((resolve) => setTimeout(resolve, config.llm.sleep ?? 1));
-  }
-  if (!config.keys.anthropicApiKey) {
-    throw new Error("Anthropic API key is not set in the config");
-  }
-  const anthropic = new Anthropic({
-    apiKey: config.keys.anthropicApiKey,
-    dangerouslyAllowBrowser: true
-  });
-  const fullPrompt = String(`${prePrompt2}
 
-
-${prompt}
-
-
-${postPrompt2}`).trim();
-  const response = await anthropic.messages.create({
-    model: config.llm.model,
-    max_tokens: 1024,
-    messages: [
-      {
-        role: "user",
-        content: fullPrompt
-      }
-    ]
-  });
-  return response;
-}
-
-// src/io/anthropic/commit-response.ts
-function commitResponseAnthropic(response) {
-  const result2 = response.content.reduce((acc, item) => {
-    const nextAcc = acc + (item.type === "text" ? item.text : "");
-    return nextAcc;
-  }, "");
-  return result2;
-}
-
-// src/io/anthropic/parse.ts
-function parseAnthropic(unparsed) {
-  if (typeof unparsed !== "string") {
-    throw new Error("CommitResponse should be a string here.");
-  }
-  const parsed = JSON.parse(unparsed);
+// src/io/ask-llm.ts
+var providerEngineMap = {
+  anthropic: "anthropic",
+  gemini: "google",
+  openai: "openai",
+  groq: "groq",
+  mistral: "mistralai",
+  ollama: "ollama",
+  xai: "xai",
+  deepseek: "deepseek",
+  openrouter: "openrouter",
+  cerebras: "cerebras",
+  lmstudio: "lmstudio",
+  azure: "azure",
+  meta: "meta"
+};
+function parseResponse(responseText) {
+  const cleaned = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
+  const parsed = JSON.parse(cleaned);
   return parsed;
 }
-async function generateResponse(prompt, config) {
-  try {
-    if (!config.keys.geminiApiKey) {
-      throw new Error("Gemini API key is not set in the config");
-    }
-    const generativeAIClient = new GoogleGenerativeAI(config.keys.geminiApiKey);
-    const model = generativeAIClient.getGenerativeModel({
-      model: config.llm.model,
-      generationConfig: {
-        temperature: config.llm.temperature ?? 0.8
-      }
-    });
-    if (config.debug) {
-      console.log("Gemini model prompt:", JSON.stringify({ prompt }));
-    }
-    const response = await model.generateContent([prompt]);
-    return response;
-  } catch (err) {
-    const error = err;
-    console.log("Error details from Gemini model", JSON.stringify({ error }, null, 2));
-    const retryDelay = error?.errorDetails?.find(
-      (detail) => detail?.["@type"] === "type.googleapis.com/google.rpc.RetryInfo"
-    )?.retryDelay ?? void 0;
-    if (error.status === 429 && retryDelay !== void 0) {
-      const sleepTime = config.llm.sleep ?? 3;
-      console.warn(
-        `Rate limit exceeded when generating response from Gemini model, retrying in... ${retryDelay} + ${sleepTime / 1e3}s`
-      );
-      await new Promise((resolve) => setTimeout(resolve, (parseInt(retryDelay, 10) + sleepTime / 1e3) * 1e3));
-      return generateResponse(prompt, config);
-    }
-    console.error("Error generating response from Gemini model", { error });
-    throw error;
-  }
-}
-async function askGemini(prompt, prePrompt2, postPrompt2) {
+async function askLLM(prompt, prePrompt2, postPrompt2) {
   const config = await awaitedConfig;
-  if (Number(config.llm.sleep)) {
-    await new Promise((resolve) => setTimeout(resolve, config.llm.sleep ?? 1));
+  const provider = config.llm.provider;
+  const engineName = providerEngineMap[provider];
+  if (!engineName) {
+    throw new Error(`Unknown LLM provider: ${provider}`);
   }
-  if (!config.keys.geminiApiKey) {
-    throw new Error("Gemini API key is not set in the config");
+  if (!config.llm.apiKey) {
+    throw new Error(`API key for ${provider} is not configured in llm.apiKey`);
   }
-  if (config.debug) {
-    console.log("\nAsking Gemini model:", JSON.stringify({ model: config.llm.model, message: prompt }));
+  if (config.llm.sleep && config.llm.sleep > 0) {
+    await new Promise((resolve) => setTimeout(resolve, config.llm.sleep));
   }
-  const fullPrompt = String(`${prePrompt2}
+  const engine = igniteEngine(engineName, {
+    apiKey: config.llm.apiKey,
+    ...config.llm.baseURL ? { baseURL: config.llm.baseURL } : {}
+  });
+  const fullPrompt = `${prePrompt2}
 
 
 ${prompt}
 
 
-${postPrompt2}`).trim();
-  let response;
-  for (let i = 0; i < 3; i++) {
-    const maybeResponse = await generateResponse(fullPrompt, config);
-    const responseString = String(maybeResponse.response.candidates?.[0]?.content?.parts?.[0]?.text ?? "").replace(/```json/g, "").replace(/```/g, "").trim();
-    if (responseString.startsWith("{") && responseString.endsWith("}")) {
-      response = maybeResponse;
-      break;
-    }
-    if (config.debug) {
-      console.log("Gemini model response is not valid, contains no JSON:", JSON.stringify({ maybeResponse }));
-    }
-  }
-  if (config.debug) {
-    console.log("Gemini model response:", JSON.stringify({ response }));
-  }
-  if (!response) {
-    throw new Error("Gemini model response is not valid");
-  }
-  return response;
-}
-
-// src/io/gemini/commit-response.ts
-function commitResponseGemini(response) {
-  const result2 = response.response.text();
-  return result2;
-}
-
-// src/io/gemini/parse.ts
-function parseGemini(unparsed) {
-  if (typeof unparsed !== "string") {
-    throw new Error("CommitResponse should be a string here.");
-  }
-  const cleaned = unparsed.replace(/```json/g, "").replace(/```/g, "");
-  const parsed = JSON.parse(cleaned);
-  return parsed;
-}
-
-// src/io/huggingface/languages-map.ts
-var languagesMap = {
-  "en-US": "eng_Latn",
-  "en-GB": "eng_Latn",
-  "pt-BR": "por_Latn",
-  "pt-PT": "por_Latn",
-  "es-ES": "spa_Latn",
-  "es-MX": "spa_Latn",
-  "fr-FR": "fra_Latn",
-  "fr-CA": "fra_Latn",
-  "de-DE": "deu_Latn",
-  "it-IT": "ita_Latn",
-  "nl-NL": "nld_Latn",
-  "pl-PL": "pol_Latn",
-  "ru-RU": "rus_Cyrl",
-  "uk-UA": "ukr_Cyrl",
-  "bg-BG": "bul_Cyrl",
-  "hr-HR": "hrv_Latn",
-  "cs-CZ": "ces_Latn",
-  "sk-SK": "slk_Latn",
-  "hu-HU": "hun_Latn",
-  "ro-RO": "ron_Latn",
-  "fi-FI": "fin_Latn",
-  "sv-SE": "swe_Latn",
-  "da-DK": "dan_Latn",
-  "no-NO": "nob_Latn",
-  "is-IS": "isl_Latn",
-  "et-EE": "est_Latn",
-  "lv-LV": "lav_Latn",
-  "lt-LT": "lit_Latn",
-  "mt-MT": "mlt_Latn",
-  "ga-IE": "gle_Latn",
-  "cy-GB": "cym_Latn",
-  "eu-ES": "eus_Latn",
-  "ca-ES": "cat_Latn",
-  "gl-ES": "glg_Latn",
-  "oc-FR": "oci_Latn",
-  "br-FR": "bre_Latn",
-  "gd-GB": "gla_Latn",
-  "kw-GB": "cor_Latn",
-  "fur-IT": "fur_Latn",
-  "rm-CH": "roh_Latn",
-  "lb-LU": "ltz_Latn",
-  "fy-NL": "fry_Latn",
-  "af-ZA": "afr_Latn",
-  "zh-CN": "zho_Hans",
-  "zh-TW": "zho_Hant",
-  "zh-HK": "zho_Hant",
-  "ja-JP": "jpn_Jpan",
-  "ko-KR": "kor_Hang",
-  "th-TH": "tha_Thai",
-  "vi-VN": "vie_Latn",
-  "id-ID": "ind_Latn",
-  "ms-MY": "zsm_Latn",
-  "tl-PH": "tgl_Latn",
-  "my-MM": "mya_Mymr",
-  "km-KH": "khm_Khmr",
-  "lo-LA": "lao_Laoo",
-  "bn-BD": "ben_Beng",
-  "bn-IN": "ben_Beng",
-  "hi-IN": "hin_Deva",
-  "ur-PK": "urd_Arab",
-  "ur-IN": "urd_Arab",
-  "pa-IN": "pan_Guru",
-  "gu-IN": "guj_Gujr",
-  "or-IN": "ory_Orya",
-  "as-IN": "asm_Beng",
-  "ml-IN": "mal_Mlym",
-  "ta-IN": "tam_Tamil",
-  "te-IN": "tel_Telu",
-  "kn-IN": "kan_Knda",
-  "si-LK": "sin_Sinh",
-  "ne-NP": "nep_Deva",
-  "dz-BT": "dzo_Tibt",
-  "bo-CN": "bod_Tibt",
-  "mn-MN": "khk_Cyrl",
-  "ka-GE": "kat_Geor",
-  "hy-AM": "hye_Armn",
-  "az-AZ": "azj_Latn",
-  "tr-TR": "tur_Latn",
-  "fa-IR": "pes_Arab",
-  "fa-AF": "pes_Arab",
-  "ps-AF": "pbt_Arab",
-  "ku-TR": "kmr_Latn",
-  "he-IL": "heb_Hebr",
-  "ar-SA": "arb_Arab",
-  "ar-EG": "arb_Arab",
-  "ar-MA": "arb_Arab",
-  "ar-DZ": "arb_Arab",
-  "ar-TN": "arb_Arab",
-  "ar-LY": "arb_Arab",
-  "ar-SD": "arb_Arab",
-  "ar-IQ": "arb_Arab",
-  "ar-SY": "arb_Arab",
-  "ar-JO": "arb_Arab",
-  "ar-LB": "arb_Arab",
-  "ar-KW": "arb_Arab",
-  "ar-AE": "arb_Arab",
-  "ar-QA": "arb_Arab",
-  "ar-BH": "arb_Arab",
-  "ar-OM": "arb_Arab",
-  "ar-YE": "arb_Arab",
-  "ar-SO": "arb_Arab",
-  "ar-DJ": "arb_Arab",
-  "ar-KM": "arb_Arab",
-  "ar-TD": "arb_Arab",
-  "ar-ER": "arb_Arab",
-  "ar-IL": "arb_Arab",
-  "ar-PS": "arb_Arab",
-  "ar-001": "arb_Arab",
-  "sw-KE": "swh_Latn",
-  "sw-TZ": "swh_Latn",
-  "am-ET": "amh_Ethi",
-  "om-ET": "gaz_Latn",
-  "so-SO": "som_Latn",
-  "ha-NG": "hau_Latn",
-  "yo-NG": "yor_Latn",
-  "ig-NG": "ibo_Latn",
-  "zu-ZA": "zul_Latn",
-  "xh-ZA": "xho_Latn",
-  "rw-RW": "kin_Latn",
-  "lg-UG": "lug_Latn",
-  "ak-GH": "aka_Latn",
-  "tw-GH": "twi_Latn",
-  "ee-GH": "ewe_Latn",
-  "ff-SN": "fuv_Latn",
-  "wo-SN": "wol_Latn",
-  "sn-ZW": "sna_Latn",
-  "nd-ZW": "nde_Latn",
-  "ny-MW": "nya_Latn",
-  "st-ZA": "sot_Latn",
-  "tn-BW": "tsn_Latn",
-  "ts-ZA": "tso_Latn",
-  "ve-ZA": "ven_Latn",
-  "ss-ZA": "ssw_Latn",
-  "nr-ZA": "nbl_Latn",
-  "qu-PE": "quy_Latn",
-  "qu-BO": "quy_Latn",
-  "qu-EC": "quy_Latn",
-  "ay-BO": "aym_Latn",
-  "gn-PY": "grn_Latn",
-  "ht-HT": "hat_Latn",
-  "jv-ID": "jav_Latn",
-  "su-ID": "sun_Latn",
-  "ceb-PH": "ceb_Latn",
-  "ilo-PH": "ilo_Latn",
-  "war-PH": "war_Latn",
-  "bjn-ID": "bjn_Latn",
-  "ban-ID": "ban_Latn",
-  "mad-ID": "mad_Latn",
-  "min-ID": "min_Latn",
-  "ace-ID": "ace_Latn",
-  "bug-ID": "bug_Latn",
-  "gor-ID": "gor_Latn",
-  "mak-ID": "mak_Latn",
-  "mdr-ID": "mdr_Latn",
-  "sas-ID": "sas_Latn",
-  "shn-MM": "shn_Mymr",
-  "kac-MM": "kac_Latn",
-  "lzh-CN": "lzh_Hant",
-  "wuu-CN": "wuu_Hans",
-  "yue-CN": "yue_Hant",
-  "nan-TW": "nan_Hant",
-  "hak-TW": "hak_Hant",
-  "cjy-CN": "cjy_Hans",
-  "cmn-CN": "cmn_Hans",
-  "cmn-TW": "cmn_Hant",
-  "cmn-SG": "cmn_Hans",
-  "cmn-HK": "cmn_Hant",
-  "cmn-MO": "cmn_Hant",
-  "cmn-001": "cmn_Hans",
-  "haw-US": "haw_Latn",
-  "mi-NZ": "mri_Latn",
-  "sm-WS": "smo_Latn",
-  "to-TO": "ton_Latn",
-  "fj-FJ": "fij_Latn",
-  "ty-PF": "tah_Latn",
-  "co-FR": "cos_Latn",
-  "eu-FR": "eus_Latn",
-  "kk-KZ": "kaz_Cyrl",
-  "ky-KG": "kir_Cyrl",
-  "uz-UZ": "uzn_Latn",
-  "tg-TJ": "tgk_Cyrl",
-  "tk-TM": "tuk_Latn"
-};
-
-// src/io/huggingface/ask.ts
-function getLanguageCode(language) {
-  return languagesMap[language];
-}
-function progressCallback(progress) {
-  process.stdout.clearLine(0);
-  process.stdout.cursorTo(0);
-  if (progress.status === "download") {
-    process.stdout.write("Downloading...");
-  } else if (progress.status === "initiate") {
-    process.stdout.write("Initializing...");
-  } else if (progress.status === "done") {
-    process.stdout.write("Done!");
-  } else if (progress.status === "progress" && "progress" in progress && "loaded" in progress && "total" in progress) {
-    process.stdout.write(
-      `Downloading: ${Number(progress.progress).toFixed(2)}%, loaded: ${progress.loaded}/${progress.total}`
-    );
-  }
-}
-async function pipeLanguage(pipe, original, srcLanguage, targetLanguage) {
-  const response = await pipe(original, {
-    src_lang: srcLanguage,
-    tgt_lang: targetLanguage,
-    temperature: 1
+${postPrompt2}`.trim();
+  const messages = [new Message("user", fullPrompt)];
+  const model = config.llm.model ?? "gpt-4o-mini";
+  const response = await engine.complete(engine.buildModel(model), messages, {
+    temperature: config.llm.temperature
   });
-  return response;
-}
-async function askHuggingface(original) {
-  const config = await awaitedConfig;
-  const cacheDir = `${config.cache.dir}/.cache`;
-  env.cacheDir = cacheDir;
-  const pipe = await pipeline("translation", config.llm.model, {
-    progress_callback: progressCallback,
-    cache_dir: cacheDir
-  });
-  const { languages } = config;
-  let responses = [];
-  for await (const language of languages) {
-    const response = await pipeLanguage(
-      pipe,
-      original,
-      getLanguageCode(config.sourceLanguage),
-      getLanguageCode(language)
-    );
-    if (Array.isArray(response)) {
-      responses = responses.concat(
-        response.map((r) => ({
-          ...r,
-          targetLanguage: language
-        }))
-      );
-    } else {
-      responses.push({
-        ...response,
-        targetLanguage: language
-      });
-    }
-  }
-  return { responses, original };
-}
-
-// src/io/huggingface/commit-response.ts
-function commitResponseHuggingface(response) {
-  const { responses, original } = response;
-  const translation = responses.reduce((acc, curr) => {
-    acc[curr.targetLanguage] = curr.translation_text;
-    return acc;
-  }, {});
-  return {
-    translation,
-    original
-  };
-}
-
-// src/io/huggingface/parse.ts
-function parseHuggingface(unparsed) {
-  if (typeof unparsed === "string") {
-    throw new Error("CommitResponse should not be a string here.");
-  }
-  return unparsed;
-}
-
-// src/io/ask-llm.ts
-var llmChoices = {
-  anthropic: {
-    ask: askAnthropic,
-    commitResponse: commitResponseAnthropic,
-    parse: parseAnthropic
-  },
-  gemini: {
-    ask: askGemini,
-    commitResponse: commitResponseGemini,
-    parse: parseGemini
-  },
-  huggingface: {
-    ask: askHuggingface,
-    commitResponse: commitResponseHuggingface,
-    parse: parseHuggingface
+  if (config.debug) {
+    console.log("LLM response:", JSON.stringify({ provider, model: config.llm.model, response: response.content }));
   }
-};
-async function processLLMChoice(llmChoice, prompt, prePrompt2, postPrompt2) {
-  const response = await llmChoice.ask(prompt, prePrompt2, postPrompt2);
-  const unparsed = llmChoice.commitResponse(response);
-  const parsed = llmChoice.parse(unparsed);
-  return parsed;
-}
-async function askLLM(prompt, prePrompt2, postPrompt2) {
-  const config = await awaitedConfig;
-  const llmChoiceName = config.llm.choice;
-  const llmChoice = llmChoices[llmChoiceName];
-  if (!llmChoice) {
-    throw new Error("LLMChoice not found");
+  if (!response.content) {
+    throw new Error("LLM response content is empty");
   }
-  return processLLMChoice(llmChoice, prompt, prePrompt2, postPrompt2);
+  return parseResponse(response.content);
 }
 
 export { askLLM };