kiku-agent 1.3.2 → 1.3.4

package/server/agent/llmClient.js

@@ -1,7 +1,10 @@
-import { config, CLOUD_PROVIDERS, normalizeProviderModel, matchModelIdentifier, extractModelQuantization, savePersistedProviderKey, savePersistedActiveProvider, savePersistedProviderModel, getPersistedActiveProvider, getProviderBaseUrl, savePersistedProviderBaseUrl, setActiveProvider } from './config.js';
+import { config, CLOUD_PROVIDERS, normalizeProviderModel, matchModelIdentifier, extractModelQuantization, savePersistedProviderKey, savePersistedActiveProvider, savePersistedProviderModel, getPersistedActiveProvider, getProviderBaseUrl, savePersistedProviderBaseUrl, setActiveProvider, getPersistedInferenceSettings } from './config.js';
 import { parseApiErrorText } from './errors.js';
 import { estimateTokens } from './telemetry.js';
-import { estimateTokenCount } from './contextCompactor.js';
+import { estimateTokenCount, prepareChatMessagesForDispatch } from './contextCompactor.js';
+import { isIpAddress, isPrivateIPv4, isPrivateIPv6 } from './sanitizer.js';
+import { applyModelRequestOptions, normalizeAssistantMessage, StreamContentNormalizer } from './modelCompatibility.js';
+import { toAnthropicMessages, toAnthropicTools, normalizeAnthropicResponse } from './cloudAdapters.js';
 
 function computeRetryDelay(attempt, headers) {
   const retryAfter = Number(headers?.get?.('retry-after'));
@@ -11,6 +14,22 @@ function computeRetryDelay(attempt, headers) {
   return Math.min(8000, 1200 * 2 ** attempt) + Math.floor(Math.random() * 400);
 }
 
+function isLocalInferenceEndpoint(baseUrl) {
+  let hostname = '';
+  try {
+    hostname = new URL(baseUrl).hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '').toLowerCase();
+  } catch {
+    return false;
+  }
+  if (hostname === 'localhost' || hostname.endsWith('.localhost') || hostname.endsWith('.local')) return true;
+  if (!isIpAddress(hostname)) return false;
+  return isPrivateIPv4(hostname) || isPrivateIPv6(hostname);
+}
+
+function parseAnthropicArgs(value) {
+  try { return JSON.parse(value || '{}'); } catch { return {}; }
+}
+
 export class LLMClient {
   constructor(options = {}) {
     const providerId = (options.provider || getPersistedActiveProvider() || config.activeProvider || 'lmstudio').toLowerCase();
@@ -25,6 +44,7 @@ export class LLMClient {
     this.apiKey = options.apiKey !== undefined
       ? options.apiKey
       : (providerDef.apiKey !== undefined ? providerDef.apiKey : (providerDef.isLocal ? (config.lmStudio.apiKey || 'lm-studio') : ''));
+    this.modelExplicitlySet = Boolean(options.model);
     this.model = normalizeProviderModel(
       providerId,
       options.model || providerDef.defaultModel || config.lmStudio.model || 'google/gemma-4-e4b'
@@ -73,6 +93,7 @@ export class LLMClient {
   setModel(model) {
     const trimmed = String(model || '').trim();
     if (!trimmed) throw new Error('A model ID is required.');
+    this.modelExplicitlySet = true;
     this.model = normalizeProviderModel(this.provider, trimmed);
     savePersistedProviderModel(this.provider, this.model);
     return this.model;
@@ -102,7 +123,9 @@ export class LLMClient {
       ...this.extraHeaders,
     };
 
-    if (this.apiKey) {
+    if (this.provider === 'anthropic') {
+      if (this.apiKey) headers['x-api-key'] = this.apiKey;
+    } else if (this.apiKey) {
       headers['Authorization'] = `Bearer ${this.apiKey}`;
       if (this.provider === 'gemini') {
         headers['x-goog-api-key'] = this.apiKey;
@@ -111,6 +134,8 @@ export class LLMClient {
       headers['Authorization'] = 'Bearer lm-studio';
     } else if (this.provider === 'vllm') {
       headers['Authorization'] = 'Bearer token-kiku';
+    } else if (this.provider === 'ollama') {
+      headers['Authorization'] = this.apiKey ? `Bearer ${this.apiKey}` : 'Bearer ollama';
     }
 
     return headers;
@@ -120,7 +145,20 @@ export class LLMClient {
     const def = CLOUD_PROVIDERS[this.provider] || {};
     const startTime = Date.now();
 
-    if (!def.isLocal && !this.apiKey) {
+    if (this.provider === 'custom' && !this.baseUrl) {
+      return {
+        connected: false,
+        provider: this.provider,
+        providerName: this.providerName,
+        error: `No base URL configured for ${this.providerName}. Set LLM_BASE_URL in .env or apply a discovered server in /settings`,
+        models: [],
+        latencyMs: 0
+      };
+    }
+
+    const keylessLocalEndpoint = this.provider === 'custom' && isLocalInferenceEndpoint(this.baseUrl);
+
+    if (!def.isLocal && !this.apiKey && !keylessLocalEndpoint) {
       return {
         connected: false,
         provider: this.provider,
@@ -130,6 +168,21 @@ export class LLMClient {
         latencyMs: 0
       };
     }
+    if (this.provider === 'anthropic') {
+      return {
+        connected: true,
+        provider: this.provider,
+        providerName: this.providerName,
+        baseUrl: this.baseUrl,
+        models: [this.model],
+        loadedModels: [this.model],
+        activeModel: this.model,
+        activeLoadedModel: this.model,
+        isModelAvailable: true,
+        isModelLoaded: true,
+        latencyMs: 0,
+      };
+    }
     try {
       const controller = new AbortController();
       const timeoutMs = process.env.NODE_ENV === 'test' || process.execArgv.includes('--test') ? 800 : 8000;
@@ -185,13 +238,38 @@ export class LLMClient {
         .map(m => m.id || m.name)
         .filter(Boolean);
 
-      const activeLoaded = loadedModels.length > 0 ? loadedModels[0] : null;
+      let activeLoaded = loadedModels.length > 0 ? loadedModels[0] : null;
+
+      if (this.provider === 'lmstudio') {
+        try {
+          const rootUrl = String(this.baseUrl || '').replace(/\/v1\/?$/, '').replace(/\/+$/, '');
+          const v0Res = await fetch(`${rootUrl}/api/v0/models`, {
+            method: 'GET',
+            headers: this._buildHeaders(),
+            signal: controller.signal
+          });
+          if (v0Res.ok) {
+            const v0Data = await v0Res.json();
+            const v0List = Array.isArray(v0Data?.data) ? v0Data.data : [];
+            const v0Loaded = v0List
+              .filter(m => m && typeof m === 'object' && m.state === 'loaded')
+              .map(m => m.id)
+              .filter(Boolean);
+            if (v0Loaded.length > 0) {
+              activeLoaded = v0Loaded[0];
+              for (const id of v0Loaded) {
+                if (!loadedModels.includes(id)) loadedModels.push(id);
+              }
+            } else if (v0List.length > 0 && loadedModels.length === 0) {
+              activeLoaded = null;
+            }
+          }
+        } catch {}
+      }
 
-      
       const exactMatch = models.find(m => m === this.model);
       const fuzzyMatch = models.find(m => matchModelIdentifier(this.model, m));
 
-     
       const modelIsGemmaOrUnset = !this.model || /gemma/i.test(this.model);
       const matchedGemma = modelIsGemmaOrUnset
         ? ((activeLoaded && /gemma/i.test(activeLoaded))
@@ -205,37 +283,53 @@ export class LLMClient {
             )))
         : null;
 
-      const resolvedActive = exactMatch || (activeLoaded ? activeLoaded : (fuzzyMatch || matchedGemma || this.model));
+      const isDefaultGemma = !this.model || this.model === 'google/gemma-4-e4b' || this.model === 'gemma-4-e4b';
+      const activeLoadedMatches = Boolean(activeLoaded && (
+        matchModelIdentifier(this.model, activeLoaded) ||
+        (isDefaultGemma && /gemma/i.test(activeLoaded))
+      ));
+
+      const resolvedActive = exactMatch || (activeLoadedMatches ? activeLoaded : (activeLoaded || fuzzyMatch || matchedGemma || this.model));
 
-      
       if (this.provider === 'lmstudio' && models.length > 0) {
         if (exactMatch) {
           this.model = exactMatch;
-        } else if (activeLoaded && (this.model === 'google/gemma-4-e4b' || matchModelIdentifier(this.model, activeLoaded))) {
+        } else if (activeLoadedMatches) {
           this.model = activeLoaded;
-        } else if (fuzzyMatch) {
+        } else if (fuzzyMatch && matchModelIdentifier(this.model, fuzzyMatch)) {
           this.model = fuzzyMatch;
-        } else if (matchedGemma && this.model === 'google/gemma-4-e4b') {
+        } else if (matchedGemma && isDefaultGemma) {
           this.model = matchedGemma;
         }
       }
 
       const isAvailable = models.length === 0 ? true : (
-        models.includes(this.model) ||
-        models.some(m => matchModelIdentifier(this.model, m)) ||
-        Boolean(activeLoaded && models.includes(activeLoaded))
+        exactMatch ? true : (
+          activeLoadedMatches ? true : (
+            (fuzzyMatch && matchModelIdentifier(this.model, fuzzyMatch)) ? true : (
+              this.modelExplicitlySet ? false : Boolean(activeLoaded && models.includes(activeLoaded))
+            )
+          )
+        )
       );
 
+      const isLocal = this.provider === 'lmstudio' || this.provider === 'vllm' || this.provider === 'ollama';
+      const effectiveLoadedModels = loadedModels.length > 0
+        ? loadedModels
+        : (isLocal ? [] : (models.length > 0 ? [models[0]] : []));
+      const isModelLoaded = isLocal ? Boolean(activeLoaded) : (models.length > 0);
+
       return {
         connected: true,
         provider: this.provider,
         providerName: this.providerName,
         baseUrl: this.baseUrl,
         models,
-        loadedModels: loadedModels.length > 0 ? loadedModels : (models.length > 0 ? [models[0]] : []),
+        loadedModels: effectiveLoadedModels,
         activeLoadedModel: activeLoaded,
         activeModel: resolvedActive,
         isModelAvailable: isAvailable,
+        isModelLoaded,
         latencyMs
       };
     } catch (err) {
@@ -262,7 +356,7 @@ export class LLMClient {
   }
 
   _isLegacyReasoningModel() {
-    return /^(o1|o3|deepseek-reasoner)/i.test(this.model) || this.model.includes('reasoner');
+    return /^(o1|o3|deepseek-reasoner)/i.test(this.model) || this.model.includes('reasoner') || /deepseek.*r1/i.test(this.model);
   }
 
 
@@ -270,47 +364,174 @@ export class LLMClient {
     return this._isLegacyReasoningModel();
   }
 
+  async _chatAnthropic({ messages, tools, temperature, maxTokens, stream, signal, onToken, onThought }) {
+    const converted = toAnthropicMessages(messages);
+    const payload = {
+      model: this.model,
+      messages: converted.messages,
+      max_tokens: maxTokens,
+      stream,
+    };
+    if (converted.system) payload.system = converted.system;
+    if (temperature !== undefined && temperature !== null) payload.temperature = temperature;
+    const anthropicTools = toAnthropicTools(tools);
+    if (anthropicTools.length > 0) {
+      payload.tools = anthropicTools;
+      payload.tool_choice = { type: 'auto' };
+    }
+
+    const response = await fetch(`${this.baseUrl}/v1/messages`, {
+      method: 'POST',
+      headers: this._buildHeaders(),
+      body: JSON.stringify(payload),
+      signal,
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const error = new Error(`${this.providerName} error (${response.status}): ${parseApiErrorText(errorText)}`);
+      error.status = response.status;
+      throw error;
+    }
+    if (!stream) return normalizeAnthropicResponse(await response.json());
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let content = '';
+    let reasoning = '';
+    const toolCalls = [];
+    const processEvent = (eventText) => {
+      const dataLine = eventText.split('\n').find(line => line.startsWith('data:'));
+      if (!dataLine) return;
+      let event;
+      try { event = JSON.parse(dataLine.replace(/^data:\s*/, '')); } catch { return; }
+      const block = event.content_block;
+      if (event.type === 'content_block_start' && block?.type === 'tool_use') {
+        toolCalls[event.index || toolCalls.length] = {
+          id: block.id || `call_${Date.now()}`,
+          type: 'function',
+          function: { name: block.name || '', arguments: '' },
+        };
+      }
+      const delta = event.delta;
+      if (!delta) return;
+      if (delta.type === 'text_delta') {
+        content += delta.text || '';
+        if (onToken) onToken(delta.text || '');
+      } else if (delta.type === 'thinking_delta') {
+        reasoning += delta.thinking || '';
+        if (onThought) onThought(delta.thinking || '');
+      } else if (delta.type === 'input_json_delta') {
+        const call = toolCalls[event.index || 0];
+        if (call) call.function.arguments += delta.partial_json || '';
+      }
+    };
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const events = buffer.split('\n\n');
+      buffer = events.pop() || '';
+      for (const event of events) processEvent(event);
+    }
+    if (buffer.trim()) processEvent(buffer);
+    return normalizeAnthropicResponse({ content: [
+      ...(content ? [{ type: 'text', text: content }] : []),
+      ...(reasoning ? [{ type: 'thinking', thinking: reasoning }] : []),
+      ...toolCalls.filter(Boolean).map(call => ({ type: 'tool_use', id: call.id, name: call.function.name, input: parseAnthropicArgs(call.function.arguments) })),
+    ] });
+  }
+
   async chat(firstArg, secondArg = {}) {
-    let messages, tools, temperature, maxTokens, stream, signal, onToken, onThought;
+    let messages, tools, temperature, topP, minP, repeatPenalty, maxTokens, stream, signal, onToken, onThought, contextLimit, thinkingMode;
+    const inferenceSettings = typeof getPersistedInferenceSettings === 'function' ? getPersistedInferenceSettings() : {};
     if (Array.isArray(firstArg)) {
       messages = firstArg;
       ({
         tools = null,
         temperature = 0.3,
+        topP = null,
+        minP = inferenceSettings.minP ?? 0.08,
+        repeatPenalty = inferenceSettings.repeatPenalty ?? 1.10,
         maxTokens = 8192,
         stream = true,
         signal = null,
         onToken = null,
-        onThought = null
+        onThought = null,
+        contextLimit = undefined,
+        thinkingMode = null
       } = secondArg || {});
     } else {
       ({
         messages,
         tools = null,
         temperature = 0.3,
+        topP = null,
+        minP = inferenceSettings.minP ?? 0.08,
+        repeatPenalty = inferenceSettings.repeatPenalty ?? 1.10,
         maxTokens = 8192,
         stream = true,
         signal = null,
         onToken = null,
-        onThought = null
+        onThought = null,
+        contextLimit = undefined,
+        thinkingMode = null
       } = firstArg || {});
     }
+    const dispatch = prepareChatMessagesForDispatch(messages, {
+      tools,
+      maxContextTokens: Number(contextLimit) || Number(process.env.KIKU_CONTEXT_LIMIT) || 32768,
+      generationReserve: maxTokens,
+      pruneAt: 0.85,
+    });
+    messages = dispatch.messages;
+    tools = dispatch.tools;
+    this.lastContextBudget = dispatch.budget;
+    if (this.provider === 'anthropic') {
+      return this._chatAnthropic({ messages, tools, temperature, maxTokens, stream, signal, onToken, onThought });
+    }
     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 sanitizedMessages = messages.map(m => {
+      if (m && m.role === 'assistant' && m.reasoning_content) {
+        const { reasoning_content, ...rest } = m;
+        return rest;
+      }
+      return m;
+    });
+
     const buildPayload = (includeTools = true, includeTemp = true) => {
       const p = {
         model: this.model,
-        messages,
+        messages: sanitizedMessages,
         stream
       };
 
       if (!rejectsTemperature && includeTemp && temperature !== undefined && temperature !== null) {
         p.temperature = temperature;
       }
+      const customTemp = temperature !== undefined && temperature !== null && Number(temperature) !== 0.3;
+      if (!rejectsTemperature && topP !== undefined && topP !== null && !customTemp) {
+        const tp = Number(topP);
+        if (Number.isFinite(tp)) p.top_p = Math.min(1, Math.max(0.01, tp));
+      }
+
+      const isLocalOrCompatible = this.provider === 'lmstudio' || this.provider === 'vllm' || this.provider === 'custom' || isLocalInferenceEndpoint(this.baseUrl);
+      if (!rejectsTemperature && !isLegacyReasoningModel && isLocalOrCompatible) {
+        if (minP !== undefined && minP !== null) {
+          const mp = Number(minP);
+          if (Number.isFinite(mp) && mp > 0 && mp <= 1) p.min_p = mp;
+        }
+        if (repeatPenalty !== undefined && repeatPenalty !== null) {
+          const rp = Number(repeatPenalty);
+          if (Number.isFinite(rp) && rp >= 1 && rp <= 2) p.repeat_penalty = rp;
+        }
+      }
 
       if (usesCompletionTokenLimit) {
         p.max_completion_tokens = maxTokens;
@@ -331,7 +552,11 @@ export class LLMClient {
         p.stream_options = { include_usage: true };
       }
 
-      return p;
+      return applyModelRequestOptions(p, {
+        provider: this.provider,
+        model: this.model,
+        thinkingMode,
+      });
     };
 
     let payload = buildPayload(true, true);
@@ -381,6 +606,10 @@ export class LLMClient {
             } else if (lowerErr.includes('temperature') && payload.temperature !== undefined) {
               payload = buildPayload(Boolean(payload.tools), false);
               retryNeeded = true;
+            } else if ((lowerErr.includes('min_p') || lowerErr.includes('repeat_penalty') || lowerErr.includes('extra') || lowerErr.includes('additional properties')) && (payload.min_p !== undefined || payload.repeat_penalty !== undefined)) {
+              delete payload.min_p;
+              delete payload.repeat_penalty;
+              retryNeeded = true;
             } else if (lowerErr.includes('max_tokens') && payload.max_tokens !== undefined) {
               delete payload.max_tokens;
               payload.max_completion_tokens = maxTokens;
@@ -442,11 +671,8 @@ export class LLMClient {
         const data = await res.json();
         clearTimeout(timeoutId);
         if (signal) signal.removeEventListener('abort', abortHandler);
-        const msg = data.choices && data.choices[0] ? data.choices[0].message : null;
+        const msg = data.choices && data.choices[0] ? normalizeAssistantMessage(data.choices[0].message || {}) : null;
         if (msg) {
-          if (!msg.reasoning_content && (msg.reasoning || msg.thinking)) {
-            msg.reasoning_content = msg.reasoning || msg.thinking;
-          }
           if (data.usage) {
             msg.usage = {
               prompt_tokens: data.usage.prompt_tokens || 0,
@@ -476,6 +702,56 @@ export class LLMClient {
       let buffer = '';
       let reportedUsage = null;
       let malformedChunks = 0;
+      const contentNormalizer = new StreamContentNormalizer();
+      const processSseLine = line => {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith('data:')) return;
+        const jsonStr = trimmed.replace(/^data:\s*/, '');
+        if (jsonStr === '[DONE]') return;
+
+        try {
+          const parsed = JSON.parse(jsonStr);
+          if (parsed.usage) reportedUsage = parsed.usage;
+          const delta = parsed.choices?.[0]?.delta;
+          if (!delta) return;
+
+          const reasoning = delta.reasoning_content || delta.reasoning || delta.thinking;
+          if (reasoning) {
+            fullReasoning += reasoning;
+            if (onThought) onThought(reasoning);
+          }
+
+          if (delta.content) {
+            const contentParts = contentNormalizer.push(delta.content);
+            if (contentParts.reasoning) {
+              fullReasoning += contentParts.reasoning;
+              if (onThought) onThought(contentParts.reasoning);
+            }
+            if (contentParts.answer) {
+              fullContent += contentParts.answer;
+              if (onToken) onToken(contentParts.answer);
+            }
+          }
+
+          const streamedToolCalls = delta.tool_calls || (delta.function_call ? [{ index: 0, function: delta.function_call }] : null);
+          if (streamedToolCalls) {
+            for (const tc of streamedToolCalls) {
+              const idx = tc.index ?? 0;
+              if (!toolCalls[idx]) {
+                toolCalls[idx] = {
+                  id: tc.id || `call_${Date.now()}_${idx}`,
+                  type: 'function',
+                  function: { name: '', arguments: '' }
+                };
+              }
+              if (tc.function?.name) toolCalls[idx].function.name += tc.function.name;
+              if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
+            }
+          }
+        } catch {
+          malformedChunks++;
+        }
+      };
 
       while (true) {
         const { done, value } = await reader.read();
@@ -486,50 +762,19 @@ export class LLMClient {
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split('\n');
         buffer = lines.pop() || '';
+        for (const line of lines) processSseLine(line);
+      }
 
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith('data:')) continue;
-          const jsonStr = trimmed.replace(/^data:\s*/, '');
-          if (jsonStr === '[DONE]') continue;
-
-          try {
-            const parsed = JSON.parse(jsonStr);
-            if (parsed.usage) {
-              reportedUsage = parsed.usage;
-            }
-            const delta = parsed.choices?.[0]?.delta;
-            if (!delta) continue;
-
-            const reasoning = delta.reasoning_content || delta.reasoning || delta.thinking;
-            if (reasoning) {
-              fullReasoning += reasoning;
-              if (onThought) onThought(reasoning);
-            }
-
-            if (delta.content) {
-              fullContent += delta.content;
-              if (onToken) onToken(delta.content);
-            }
+      if (buffer.trim()) processSseLine(buffer);
 
-            if (delta.tool_calls) {
-              for (const tc of delta.tool_calls) {
-                const idx = tc.index ?? 0;
-                if (!toolCalls[idx]) {
-                  toolCalls[idx] = {
-                    id: tc.id || `call_${Date.now()}_${idx}`,
-                    type: 'function',
-                    function: { name: '', arguments: '' }
-                  };
-                }
-                if (tc.function?.name) toolCalls[idx].function.name += tc.function.name;
-                if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
-              }
-            }
-          } catch {
-            malformedChunks++;
-          }
-        }
+      const finalContentParts = contentNormalizer.flush();
+      if (finalContentParts.reasoning) {
+        fullReasoning += finalContentParts.reasoning;
+        if (onThought) onThought(finalContentParts.reasoning);
+      }
+      if (finalContentParts.answer) {
+        fullContent += finalContentParts.answer;
+        if (onToken) onToken(finalContentParts.answer);
       }
 
       clearTimeout(timeoutId);
@@ -555,9 +800,10 @@ export class LLMClient {
 
       const totalTokens = reportedUsage?.total_tokens ?? (promptTokens + completionTokens);
 
-      const resultMessage = {
+      const rawToolContent = finalContentParts.toolCallBuffer || '';
+      const resultMessage = normalizeAssistantMessage({
         role: 'assistant',
-        content: fullContent,
+        content: fullContent + (rawToolContent ? `\n${rawToolContent}` : ''),
         reasoning_content: fullReasoning,
         usage: {
           prompt_tokens: promptTokens,
@@ -565,7 +811,7 @@ export class LLMClient {
           reasoning_tokens: reasoningTokens,
           total_tokens: totalTokens
         }
-      };
+      });
 
       if (toolCalls.length > 0) {
         resultMessage.tool_calls = toolCalls.filter(Boolean);