@intranefr/superbackend 1.5.2 → 1.6.3

package/src/services/llm.service.js

@@ -15,6 +15,22 @@ let cache = {
 const CACHE_TTL = 60000;
 
 
+const logger = {
+  log: (...args) => {
+    if (process.env.DEBUG_LLM === 'true' && process.env.NODE_ENV !== 'test') {
+       if (!process.env.TUI_MODE) console.log(...args);
+    }
+  },
+  warn: (...args) => {
+    if (process.env.DEBUG_LLM === 'true' && process.env.NODE_ENV !== 'test') {
+       if (!process.env.TUI_MODE) console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    console.error(...args);
+  }
+};
+
 function computeCompletionURL(baseUrl) {
   const trimmed = baseUrl.replace(/\/$/, "");
 
@@ -294,6 +310,8 @@ async function call(promptKey, variables = {}, runtimeOptions = {}) {
     "stop",
     "n",
     "stream",
+    "tools",
+    "tool_choice",
   ];
 
   for (const key of allowedOptions) {
@@ -313,7 +331,7 @@ async function call(promptKey, variables = {}, runtimeOptions = {}) {
       `-H "Content-Type: application/json"`,
       ...Object.entries(provider.extraHeaders || {}).map(([k, v]) => `-H "${k}: ${v}"`),
     ].join(' ');
-    console.log(`[llm.service] curl equivalent:\n  curl -X POST ${url} ${curlHeaders} -d '${JSON.stringify(body)}'\n`);
+    logger.log(`[llm.service] curl equivalent:\n  curl -X POST ${url} ${curlHeaders} -d '${JSON.stringify(body)}'\n`);
 
     response = await axios.post(url, body, {
       headers: {
@@ -394,6 +412,40 @@ async function call(promptKey, variables = {}, runtimeOptions = {}) {
   };
 }
 
+let modelMetadataCache = {
+  data: {},
+  ts: 0
+};
+const MODEL_CACHE_TTL = 3600000;
+
+async function getModelContextLength(modelId, providerKey) {
+  if (modelMetadataCache.ts && Date.now() - modelMetadataCache.ts < MODEL_CACHE_TTL) {
+    if (modelMetadataCache.data[modelId]) return modelMetadataCache.data[modelId];
+  }
+
+  if (providerKey !== 'openrouter') return 200000;
+
+  try {
+    const { providers } = await loadConfig();
+    const provider = providers[providerKey];
+    if (!provider || !provider.apiKey) return 200000;
+
+    const res = await axios.get(`https://openrouter.ai/api/v1/models/${modelId}`, {
+      headers: { 'Authorization': `Bearer ${provider.apiKey}` }
+    });
+
+    const contextLength = res?.data?.data?.context_length || 200000;
+    
+    modelMetadataCache.data[modelId] = contextLength;
+    modelMetadataCache.ts = Date.now();
+    
+    return contextLength;
+  } catch (e) {
+    logger.warn(`[llm.service] Failed to fetch context length for ${modelId}:`, e.message);
+    return 200000;
+  }
+}
+
 async function callAdhoc(
   {
     providerKey,
@@ -409,9 +461,9 @@ async function callAdhoc(
   const key = String(providerKey || "").trim();
   let provider = providers[key];
   
-  console.log('[llm.service] callAdhoc providerKey:', key);
-  console.log('[llm.service] callAdhoc available provider keys:', Object.keys(providers));
-  console.log('[llm.service] callAdhoc found provider:', !!provider, provider ? { enabled: provider.enabled, hasApiKey: !!provider.apiKey } : null);
+  logger.log('[llm.service] callAdhoc providerKey:', key);
+  logger.log('[llm.service] callAdhoc available provider keys:', Object.keys(providers));
+  logger.log('[llm.service] callAdhoc found provider:', !!provider, provider ? { enabled: provider.enabled, hasApiKey: !!provider.apiKey } : null);
   
   // Apply runtime overrides for provider if possible
   if (runtimeOptions.apiKey || runtimeOptions.baseUrl) {
@@ -456,6 +508,8 @@ async function callAdhoc(
     "stop",
     "n",
     "stream",
+    "tools",
+    "tool_choice",
   ];
 
   for (const key of allowedOptions) {
@@ -467,6 +521,7 @@ async function callAdhoc(
   let response;
   let text = "";
   let usage = null;
+  let toolCalls = null;
 
   try {
     // Debug: log curl equivalent
@@ -475,7 +530,7 @@ async function callAdhoc(
       `-H "Content-Type: application/json"`,
       ...Object.entries(provider.extraHeaders || {}).map(([k, v]) => `-H "${k}: ${v}"`),
     ].join(' ');
-    console.log(`[llm.service] adhoc curl equivalent:\n  curl -X POST ${url} ${curlHeaders} -d '${JSON.stringify(body)}'\n`);
+    logger.log(`[llm.service] adhoc curl equivalent:\n  curl -X POST ${url} ${curlHeaders} -d '${JSON.stringify(body)}'\n`);
 
     response = await axios.post(url, body, {
       headers: {
@@ -495,6 +550,10 @@ async function callAdhoc(
       choice && choice.message && typeof choice.message.content === "string"
         ? choice.message.content
         : "";
+    
+    toolCalls = choice && choice.message && Array.isArray(choice.message.tool_calls)
+        ? choice.message.tool_calls
+        : null;
 
     const rawUsage = data.usage || null;
     const normalized = normalizeUsage(rawUsage);
@@ -550,6 +609,7 @@ async function callAdhoc(
 
   return {
     content: text,
+    toolCalls,
     model: resolvedModel,
     providerKey: provider.key,
     usage,
@@ -634,7 +694,7 @@ async function stream(promptKey, variables = {}, runtimeOptions = {}, { onToken
       `-H "Content-Type: application/json"`,
       ...Object.entries(provider.extraHeaders || {}).map(([k, v]) => `-H "${k}: ${v}"`),
     ].join(' ');
-    console.log(`[llm.service] streaming curl equivalent:\n  curl -X POST ${url} ${curlHeaders} -d '${JSON.stringify(body)}'\n`);
+    logger.log(`[llm.service] streaming curl equivalent:\n  curl -X POST ${url} ${curlHeaders} -d '${JSON.stringify(body)}'\n`);
 
     const response = await axios.post(url, body, {
       headers: {
@@ -741,9 +801,162 @@ async function stream(promptKey, variables = {}, runtimeOptions = {}, { onToken
   }
 }
 
+async function streamAdhoc(
+  {
+    providerKey,
+    model,
+    messages,
+    promptKeyForAudit,
+  },
+  runtimeOptions = {},
+  { onToken, onReasoning } = {}
+) {
+  const { providers: rawProviders } = await loadConfig();
+  const providers = normalizeProviderConfig(rawProviders);
+
+  const key = String(providerKey || "").trim();
+  let provider = providers[key];
+  
+  if (runtimeOptions.apiKey || runtimeOptions.baseUrl) {
+    provider = {
+      ...(provider || { key: key || 'custom', enabled: true, baseUrl: 'https://openrouter.ai/api/v1' }),
+      ...(runtimeOptions.apiKey ? { apiKey: runtimeOptions.apiKey } : {}),
+      ...(runtimeOptions.baseUrl ? { baseUrl: runtimeOptions.baseUrl } : {}),
+    };
+  }
+
+  if (!provider || provider.enabled === false || !provider.apiKey) {
+    throw new Error("Provider not found, disabled, or missing apiKey");
+  }
+
+  const resolvedModel = String(model || runtimeOptions.model || provider.defaultModel || "google/gemini-2.5-flash-lite").trim();
+  const inputMessages = Array.isArray(messages) ? messages : [];
+  if (!inputMessages.length) throw new Error("messages is required");
+
+  const url = computeCompletionURL(provider.baseUrl);
+  const body = {
+    model: resolvedModel,
+    messages: inputMessages,
+    stream: true
+  };
+
+  const allowedOptions = ["temperature", "top_p", "max_tokens", "presence_penalty", "frequency_penalty", "stop", "n", "tools", "tool_choice"];
+  for (const key of allowedOptions) {
+    if (runtimeOptions[key] !== undefined) body[key] = runtimeOptions[key];
+  }
+
+  let fullText = "";
+  let fullReasoning = "";
+  let lastUsage = null;
+  let toolCalls = [];
+
+  const curlHeaders = [
+    `-H "Authorization: Bearer ${provider.apiKey}"`,
+    `-H "Content-Type: application/json"`,
+    ...Object.entries(provider.extraHeaders || {}).map(([k, v]) => `-H "${k}: ${v}"`),
+  ].join(' ');
+  logger.log(`[llm.service] streamAdhoc curl equivalent:\n  curl -X POST ${url} ${curlHeaders} -d '${JSON.stringify(body)}'\n`);
+
+  const response = await axios.post(url, body, {
+    headers: {
+      Authorization: `Bearer ${provider.apiKey}`,
+      "Content-Type": "application/json",
+      ...provider.extraHeaders,
+    },
+    timeout: provider.timeoutMs,
+    responseType: "stream",
+  });
+
+  await new Promise((resolve, reject) => {
+    let buffer = "";
+    response.data.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data:")) continue;
+        const payload = trimmed.slice(5).trim();
+        if (payload === "[DONE]") continue;
+
+        try {
+          const parsed = JSON.parse(payload);
+          if (parsed.usage) lastUsage = parsed.usage;
+
+          const choice = parsed.choices?.[0];
+          if (!choice) {
+            const topReasoning = parsed.reasoning_content || parsed.reasoning || parsed.thinking;
+            if (topReasoning) {
+                fullReasoning += topReasoning;
+                if (onReasoning) onReasoning(topReasoning);
+            }
+            continue;
+          }
+
+          const delta = choice.delta || {};
+          
+          if (delta.content) {
+            fullText += delta.content;
+            if (onToken) onToken(delta.content);
+          }
+
+          const reasoning = delta.reasoning_content || delta.reasoning || delta.thinking || choice.reasoning_content || choice.reasoning;
+          if (reasoning) {
+            fullReasoning += reasoning;
+            if (onReasoning) onReasoning(reasoning);
+          }
+
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              if (tc.index === undefined) tc.index = 0;
+              if (!toolCalls[tc.index]) {
+                toolCalls[tc.index] = {
+                  id: tc.id,
+                  type: 'function',
+                  function: { name: '', arguments: '' }
+                };
+              }
+              if (tc.id) toolCalls[tc.index].id = tc.id;
+              if (tc.function?.name) toolCalls[tc.index].function.name += tc.function.name;
+              if (tc.function?.arguments) toolCalls[tc.index].function.arguments += tc.function.arguments;
+            }
+          }
+        } catch (e) {}
+      }
+    });
+
+    response.data.on("end", () => resolve());
+    response.data.on("error", (err) => reject(err));
+  });
+
+  const finalUsage = normalizeUsage(lastUsage);
+
+  await logAuditEntry({
+    promptKey: String(promptKeyForAudit || "adhoc_stream"),
+    providerKey: provider.key,
+    model: resolvedModel,
+    variables: {},
+    requestOptions: runtimeOptions,
+    outcome: "success",
+    usage: finalUsage,
+  });
+
+  return {
+    content: fullText,
+    reasoning: fullReasoning,
+    toolCalls: toolCalls.length > 0 ? toolCalls : null,
+    model: resolvedModel,
+    providerKey: provider.key,
+    usage: finalUsage
+  };
+}
+
 module.exports = {
   call,
   testPrompt,
   callAdhoc,
+  streamAdhoc,
   stream,
+  getModelContextLength
 };