kiku-agent 1.2.0 → 1.3.0

package/server/agent/llmClient.js

@@ -1,6 +1,15 @@
-import { config, CLOUD_PROVIDERS, normalizeProviderModel, matchModelIdentifier, extractModelQuantization, savePersistedProviderKey, savePersistedActiveProvider, savePersistedProviderModel, getPersistedActiveProvider } from './config.js';
+import { config, CLOUD_PROVIDERS, normalizeProviderModel, matchModelIdentifier, extractModelQuantization, savePersistedProviderKey, savePersistedActiveProvider, savePersistedProviderModel, getPersistedActiveProvider, getProviderBaseUrl, savePersistedProviderBaseUrl, setActiveProvider } from './config.js';
 import { parseApiErrorText } from './errors.js';
 import { estimateTokens } from './telemetry.js';
+import { estimateTokenCount } from './contextCompactor.js';
+
+function computeRetryDelay(attempt, headers) {
+  const retryAfter = Number(headers?.get?.('retry-after'));
+  if (Number.isFinite(retryAfter) && retryAfter > 0) {
+    return Math.min(retryAfter * 1000, 15000) + Math.floor(Math.random() * 400);
+  }
+  return Math.min(8000, 1200 * 2 ** attempt) + Math.floor(Math.random() * 400);
+}
 
 export class LLMClient {
   constructor(options = {}) {
@@ -12,7 +21,7 @@ export class LLMClient {
 
     this.provider = providerId;
     this.providerName = providerDef.name || providerId;
-    this.baseUrl = (options.baseUrl || providerDef.baseUrl || config.lmStudio.baseUrl).replace(/\/+$/, '');
+    this.baseUrl = (options.baseUrl || getProviderBaseUrl(providerId) || providerDef.baseUrl || config.lmStudio.baseUrl).replace(/\/+$/, '');
     this.apiKey = options.apiKey !== undefined
       ? options.apiKey
       : (providerDef.apiKey !== undefined ? providerDef.apiKey : (providerDef.isLocal ? (config.lmStudio.apiKey || 'lm-studio') : ''));
@@ -33,12 +42,21 @@ export class LLMClient {
 
     this.provider = pId;
     this.providerName = providerDef.name || pId;
-    this.baseUrl = (options.baseUrl || providerDef.baseUrl).replace(/\/+$/, '');
+    this.baseUrl = (options.baseUrl || getProviderBaseUrl(pId) || providerDef.baseUrl).replace(/\/+$/, '');
     this.apiKey = options.apiKey !== undefined ? options.apiKey : (providerDef.apiKey || '');
     this.model = normalizeProviderModel(pId, options.model || providerDef.defaultModel);
     this.extraHeaders = { ...(providerDef.extraHeaders || {}), ...(options.extraHeaders || {}) };
 
-    savePersistedActiveProvider(pId, this.model);
+    setActiveProvider(pId, { model: this.model, baseUrl: options.baseUrl || null });
+    return this.getProviderInfo();
+  }
+
+  setBaseUrl(baseUrl, providerId = null) {
+    const targetProvider = String(providerId || this.provider).toLowerCase().trim();
+    const cleanUrl = savePersistedProviderBaseUrl(targetProvider, baseUrl);
+    if (targetProvider === this.provider) {
+      this.baseUrl = cleanUrl;
+    }
     return this.getProviderInfo();
   }
 
@@ -91,6 +109,8 @@ export class LLMClient {
       }
     } else if (this.provider === 'lmstudio') {
       headers['Authorization'] = 'Bearer lm-studio';
+    } else if (this.provider === 'vllm') {
+      headers['Authorization'] = 'Bearer token-kiku';
     }
 
     return headers;
@@ -141,6 +161,9 @@ export class LLMClient {
         } else if (res.status === 429) {
           formattedError = `429 Rate Limit / Quota Exceeded: ${errSnippet}`;
         }
+        if (def.platformNotice && process.platform === 'win32') {
+          formattedError += `\n  Notice: ${def.platformNotice}`;
+        }
 
         return {
           connected: false,
@@ -168,16 +191,19 @@ export class LLMClient {
       const exactMatch = models.find(m => m === this.model);
       const fuzzyMatch = models.find(m => matchModelIdentifier(this.model, m));
 
-      
-      const matchedGemma = (activeLoaded && /gemma/i.test(activeLoaded))
-        ? activeLoaded
-        : (fuzzyMatch || models.find(m =>
-            m === 'google/gemma-4-e4b' ||
-            m === 'gemma-4-e4b' ||
-            m.toLowerCase().includes('gemma-4-e4b') ||
-            (m.toLowerCase().includes('gemma') && m.toLowerCase().includes('e4b')) ||
-            /gemma/i.test(m)
-          ));
+     
+      const modelIsGemmaOrUnset = !this.model || /gemma/i.test(this.model);
+      const matchedGemma = modelIsGemmaOrUnset
+        ? ((activeLoaded && /gemma/i.test(activeLoaded))
+          ? activeLoaded
+          : (fuzzyMatch || models.find(m =>
+              m === 'google/gemma-4-e4b' ||
+              m === 'gemma-4-e4b' ||
+              m.toLowerCase().includes('gemma-4-e4b') ||
+              (m.toLowerCase().includes('gemma') && m.toLowerCase().includes('e4b')) ||
+              /gemma/i.test(m)
+            )))
+        : null;
 
       const resolvedActive = exactMatch || (activeLoaded ? activeLoaded : (fuzzyMatch || matchedGemma || this.model));
 
@@ -214,32 +240,66 @@ export class LLMClient {
       };
     } catch (err) {
       const latencyMs = Date.now() - startTime;
+      let errMsg = err.name === 'AbortError'
+        ? `Connection timed out at ${this.baseUrl} (>8s)`
+        : `Cannot reach ${this.providerName} at ${this.baseUrl} (${err.message})`;
+      if (def.platformNotice && process.platform === 'win32') {
+        errMsg += `\n  Notice: ${def.platformNotice}`;
+      }
       return {
         connected: false,
         provider: this.provider,
         providerName: this.providerName,
-        error: err.name === 'AbortError'
-          ? `Connection timed out at ${this.baseUrl} (>8s)`
-          : `Cannot reach ${this.providerName} at ${this.baseUrl} (${err.message})`,
+        error: errMsg,
         models: [],
         latencyMs
       };
     }
   }
 
-  async chat({
-    messages,
-    tools = null,
-    temperature = 0.3,
-    maxTokens = 8192,
-    stream = true,
-    signal = null,
-    onToken = null,
-    onThought = null
-  }) {
-    const isLegacyReasoningModel = /^(o1|o3|deepseek-reasoner)/i.test(this.model) || this.model.includes('reasoner');
+  async healthCheck() {
+    return this.checkConnection();
+  }
+
+  _isLegacyReasoningModel() {
+    return /^(o1|o3|deepseek-reasoner)/i.test(this.model) || this.model.includes('reasoner');
+  }
+
+
+  toolsWillBeOmitted() {
+    return this._isLegacyReasoningModel();
+  }
+
+  async chat(firstArg, secondArg = {}) {
+    let messages, tools, temperature, maxTokens, stream, signal, onToken, onThought;
+    if (Array.isArray(firstArg)) {
+      messages = firstArg;
+      ({
+        tools = null,
+        temperature = 0.3,
+        maxTokens = 8192,
+        stream = true,
+        signal = null,
+        onToken = null,
+        onThought = null
+      } = secondArg || {});
+    } else {
+      ({
+        messages,
+        tools = null,
+        temperature = 0.3,
+        maxTokens = 8192,
+        stream = true,
+        signal = null,
+        onToken = null,
+        onThought = null
+      } = firstArg || {});
+    }
+    const isLegacyReasoningModel = this._isLegacyReasoningModel();
     const usesCompletionTokenLimit = /^(o1|o3|gpt-5(?:\.|-|$))/i.test(this.model);
     const rejectsTemperature = /^(o1|o3|gpt-5(?:\.|-|$))/i.test(this.model);
+   
+    this.toolsDisabledReason = null;
 
     const buildPayload = (includeTools = true, includeTemp = true) => {
       const p = {
@@ -258,9 +318,13 @@ export class LLMClient {
         p.max_tokens = maxTokens;
       }
 
-      if (includeTools && tools && Array.isArray(tools) && tools.length > 0 && !isLegacyReasoningModel) {
-        p.tools = tools;
-        p.tool_choice = "auto";
+      if (includeTools && tools && Array.isArray(tools) && tools.length > 0) {
+        if (isLegacyReasoningModel) {
+          this.toolsDisabledReason = 'reasoning_model';
+        } else {
+          p.tools = tools;
+          p.tool_choice = "auto";
+        }
       }
 
       if (stream) {
@@ -278,7 +342,11 @@ export class LLMClient {
     const abortHandler = () => controller.abort();
     if (signal) signal.addEventListener('abort', abortHandler, { once: true });
 
+    let lastTimeoutReset = 0;
     const resetTimeout = () => {
+      const now = Date.now();
+      if (now - lastTimeoutReset < 500) return;
+      lastTimeoutReset = now;
       clearTimeout(timeoutId);
       timeoutId = setTimeout(() => controller.abort(), this.timeout);
     };
@@ -308,6 +376,7 @@ export class LLMClient {
 
             if ((lowerErr.includes('tool') || lowerErr.includes('function') || lowerErr.includes('schema')) && payload.tools) {
               payload = buildPayload(false, true);
+              this.toolsDisabledReason = 'provider_rejected_schema';
               retryNeeded = true;
             } else if (lowerErr.includes('temperature') && payload.temperature !== undefined) {
               payload = buildPayload(Boolean(payload.tools), false);
@@ -345,8 +414,7 @@ export class LLMClient {
           }
 
           if ([429, 500, 502, 503, 504].includes(res.status) && attempt < maxRetries && !controller.signal.aborted) {
-            const backoffMs = (attempt + 1) * 1200;
-            await new Promise(r => setTimeout(r, backoffMs));
+            await new Promise(r => setTimeout(r, computeRetryDelay(attempt, res.headers)));
             continue;
           }
 
@@ -362,8 +430,7 @@ export class LLMClient {
           if (controller.signal.aborted || attempt >= maxRetries || fetchErr.status) {
             throw fetchErr;
           }
-          const backoffMs = (attempt + 1) * 1200;
-          await new Promise(r => setTimeout(r, backoffMs));
+          await new Promise(r => setTimeout(r, computeRetryDelay(attempt, null)));
         }
       }
 
@@ -388,8 +455,7 @@ export class LLMClient {
               total_tokens: data.usage.total_tokens || ((data.usage.prompt_tokens || 0) + (data.usage.completion_tokens || 0))
             };
           } else {
-            const inputPrompt = messages.map(m => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content || ''))).join('\n');
-            const pTokens = estimateTokens(inputPrompt);
+            const pTokens = estimateTokenCount(messages);
             const cTokens = estimateTokens(msg.content || '');
             msg.usage = {
               prompt_tokens: pTokens,
@@ -409,6 +475,7 @@ export class LLMClient {
       let toolCalls = [];
       let buffer = '';
       let reportedUsage = null;
+      let malformedChunks = 0;
 
       while (true) {
         const { done, value } = await reader.read();
@@ -460,19 +527,24 @@ export class LLMClient {
               }
             }
           } catch {
+            malformedChunks++;
           }
         }
       }
 
       clearTimeout(timeoutId);
 
+      if (malformedChunks > 0) {
+      
+        console.warn(`[${this.providerName}] Dropped ${malformedChunks} malformed SSE chunk(s) during streaming.`);
+      }
+
       let promptTokens = reportedUsage?.prompt_tokens ?? 0;
       let completionTokens = reportedUsage?.completion_tokens ?? 0;
       let reasoningTokens = reportedUsage?.completion_tokens_details?.reasoning_tokens ?? 0;
 
       if (!promptTokens) {
-        const inputPrompt = messages.map(m => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content || ''))).join('\n');
-        promptTokens = estimateTokens(inputPrompt);
+        promptTokens = estimateTokenCount(messages);
       }
       if (!completionTokens) {
         completionTokens = estimateTokens(fullContent + (fullReasoning || ''));

package/server/agent/lmStudioWakeup.js

@@ -0,0 +1,144 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+
+export async function isLmStudioResponding(baseUrl = 'http://127.0.0.1:1234/v1', timeoutMs = 2500) {
+  try {
+    const root = baseUrl.replace(/\/v1\/?$/, '').replace(/\/+$/, '');
+    const res = await fetch(`${root}/v1/models`, { signal: AbortSignal.timeout(timeoutMs) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function getLoadedModels(baseUrl = 'http://127.0.0.1:1234/v1', timeoutMs = 2500) {
+  try {
+    const root = baseUrl.replace(/\/v1\/?$/, '').replace(/\/+$/, '');
+    const res = await fetch(`${root}/v1/models`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return Array.isArray(data.data) ? data.data.map(m => m.id) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function resolveLmsCli() {
+  const userHome = os.homedir();
+  const isWin = process.platform === 'win32';
+  const candidates = [
+    path.join(userHome, '.lmstudio', 'bin', isWin ? 'lms.exe' : 'lms'),
+    isWin ? 'lms.exe' : 'lms'
+  ];
+  return candidates.find(c => {
+    try { return fs.existsSync(c); } catch { return false; }
+  }) || (isWin ? 'lms.exe' : 'lms');
+}
+
+export async function loadLmStudioModel(model, options = {}) {
+  const lmsCmd = resolveLmsCli();
+  return new Promise((resolve) => {
+    const args = ['load', model, '-y', '--identifier', model];
+    const child = spawn(lmsCmd, args, {
+      windowsHide: true,
+      stdio: 'pipe',
+      shell: process.platform === 'win32'
+    });
+    let output = '';
+    child.stdout?.on('data', d => { output += d.toString(); });
+    child.stderr?.on('data', d => { output += d.toString(); });
+    child.on('close', code => {
+      resolve({ ok: code === 0, output });
+    });
+    child.on('error', err => {
+      resolve({ ok: false, error: err.message });
+    });
+  });
+}
+
+export async function wakeUpLmStudio(options = {}) {
+  const {
+    baseUrl = 'http://127.0.0.1:1234/v1',
+    model = 'google/gemma-4-e4b',
+    maxWaitMs = 35000
+  } = options;
+
+  const isLocal = baseUrl.includes('127.0.0.1') || baseUrl.includes('localhost');
+  if (!isLocal) {
+    return { ok: false, reason: 'Non-local endpoint, automatic wakeup skipped' };
+  }
+
+
+  let serverUp = await isLmStudioResponding(baseUrl, 2000);
+  if (!serverUp) {
+    const userHome = os.homedir();
+    const possiblePaths = [
+      path.join(userHome, 'AppData', 'Local', 'Programs', 'LM Studio', 'LM Studio.exe'),
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'LM Studio', 'LM Studio.exe'),
+      'C:\\Program Files\\LM Studio\\LM Studio.exe'
+    ];
+
+    const appExe = possiblePaths.find(p => p && fs.existsSync(p));
+    if (appExe) {
+      try {
+        const child = spawn(appExe, [], {
+          detached: true,
+          stdio: 'ignore',
+          windowsHide: false
+        });
+        child.unref();
+      } catch {}
+    }
+
+    try {
+      const lmsCmd = resolveLmsCli();
+      const lmsChild = spawn(lmsCmd, ['server', 'start'], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        shell: process.platform === 'win32'
+      });
+      lmsChild.unref();
+    } catch {}
+
+    const start = Date.now();
+    while (Date.now() - start < maxWaitMs) {
+      await new Promise(r => setTimeout(r, 1500));
+      if (await isLmStudioResponding(baseUrl, 2000)) {
+        serverUp = true;
+        break;
+      }
+    }
+  }
+
+  if (!serverUp) {
+    return { ok: false, reason: 'Timed out waiting for LM Studio server' };
+  }
+
+
+  if (model) {
+    const loaded = await getLoadedModels(baseUrl);
+    if (!loaded.includes(model)) {
+      try {
+        process.stdout.write(`\n🌸 [Kiku Auto-Wakeup] LM Studio server active. Auto-loading model "${model}" into VRAM...\n`);
+      } catch {}
+      await loadLmStudioModel(model);
+
+      const start = Date.now();
+      while (Date.now() - start < maxWaitMs) {
+        await new Promise(r => setTimeout(r, 1500));
+        const currentModels = await getLoadedModels(baseUrl);
+        if (currentModels.includes(model)) {
+          try {
+            process.stdout.write(`🌸 [Kiku Auto-Wakeup] Model "${model}" loaded and ready!\n\n`);
+          } catch {}
+          return { ok: true, awakened: true, modelLoaded: true };
+        }
+      }
+    }
+  }
+
+  return { ok: true, alreadyRunning: true };
+}

package/server/agent/mcpClient.js

@@ -185,7 +185,6 @@ export class McpClientManager {
       let resources = serverConfig.resources || [];
       let prompts = serverConfig.prompts || [];
 
-      // If tools not pre-provided, fetch once upon connection
       if (!tools || tools.length === 0) {
         try {
           if (!this._isRateLimited(name)) {
@@ -570,7 +569,6 @@ export class McpClientManager {
           if (cfg.enabled === false || cfg.disabled === true) continue;
           if (this.servers.has(name)) continue;
 
-          // If tools are cached or it's a known Kiku remote MCP server, register lazily without network call on startup
           let tools = cfg.tools;
           if (!tools || tools.length === 0) {
             if (name === 'kiku-mcp' || /jujingyi-kikuuu|vercel\.app/i.test(cfg.url || '')) {
@@ -641,3 +639,5 @@ export class McpClientManager {
     return results;
   }
 }
+
+export const mcpClientManager = new McpClientManager();