kiku-agent 1.2.0 → 1.3.1

package/server/agent/lanDiscovery.js

@@ -0,0 +1,369 @@
+import net from 'node:net';
+import os from 'node:os';
+import { isPrivateIPv4 } from './sanitizer.js';
+
+export const DEFAULT_LLM_PORTS = Object.freeze([1234, 8000, 11434, 8080]);
+
+const CACHE_TTL_MS = 60_000;
+
+const SERVER_TYPE_LABELS = Object.freeze({
+  lmstudio: 'LM Studio',
+  vllm: 'vLLM',
+  ollama: 'Ollama',
+  'openai-compatible': 'OpenAI-Compatible',
+});
+
+export function mapServerTypeToProvider(serverType) {
+  if (serverType === 'lmstudio') return 'lmstudio';
+  if (serverType === 'vllm') return 'vllm';
+  return 'custom';
+}
+
+function parseIpv4(host) {
+  const parts = String(host || '').split('.');
+  if (parts.length !== 4) return null;
+  const octets = parts.map(p => Number(p));
+  if (octets.some(n => !Number.isInteger(n) || n < 0 || n > 255)) return null;
+  return octets;
+}
+
+export function getLanCandidateSubnets(interfaces = os.networkInterfaces()) {
+  const seen = new Set();
+  const subnets = [];
+  for (const [name, addresses] of Object.entries(interfaces || {})) {
+    for (const entry of addresses || []) {
+      if (!entry || entry.internal || entry.family !== 'IPv4') continue;
+      const octets = parseIpv4(entry.address);
+      if (!octets || octets[0] === 127) continue;
+      if (octets[0] === 169 && octets[1] === 254) continue;
+      if (!isPrivateIPv4(entry.address)) continue;
+      const cidr = `${octets[0]}.${octets[1]}.${octets[2]}.0/24`;
+      if (seen.has(cidr)) continue;
+      seen.add(cidr);
+      subnets.push({ cidr, interfaceName: name, address: entry.address });
+    }
+  }
+  return subnets;
+}
+
+export function expandCidrToHosts(cidr) {
+  const base = String(cidr || '').split('/')[0];
+  const octets = parseIpv4(base);
+  if (!octets) throw new Error(`Invalid CIDR "${cidr}"`);
+  const hosts = [];
+  for (let last = 1; last <= 254; last++) {
+    hosts.push(`${octets[0]}.${octets[1]}.${octets[2]}.${last}`);
+  }
+  return hosts;
+}
+
+export const DEFAULT_MAX_SCAN_HOSTS = 4096;
+
+function ipv4ToUint32(octets) {
+  return ((octets[0] << 24) | (octets[1] << 16) | (octets[2] << 8) | octets[3]) >>> 0;
+}
+
+function uint32ToIp(value) {
+  return `${(value >>> 24) & 255}.${(value >>> 16) & 255}.${(value >>> 8) & 255}.${value & 255}`;
+}
+
+export function expandTargets(specs, { maxHosts = DEFAULT_MAX_SCAN_HOSTS } = {}) {
+  const list = Array.isArray(specs) ? specs : String(specs || '').split(',');
+  const out = [];
+  const seen = new Set();
+  let planned = 0;
+
+  const pushIp = value => {
+    const ip = uint32ToIp(value);
+    if (!seen.has(ip)) {
+      seen.add(ip);
+      out.push(ip);
+    }
+  };
+
+  for (const raw of list) {
+    const spec = String(raw || '').trim();
+    if (!spec) continue;
+
+    if (spec.includes('/')) {
+      const [base, prefixStr] = spec.split('/');
+      const octets = parseIpv4(base);
+      const prefix = Number(prefixStr);
+      if (!octets || !Number.isInteger(prefix) || prefix < 8 || prefix > 32) {
+        throw new Error(`Invalid CIDR "${spec}" (expected a.b.c.d/8..32)`);
+      }
+      const network = prefix === 0 ? 0 : (ipv4ToUint32(octets) & (0xffffffff << (32 - prefix))) >>> 0;
+      const size = 2 ** (32 - prefix);
+      const usable = prefix <= 30 ? size - 2 : size;
+      planned += usable;
+      if (planned > maxHosts) {
+        throw new Error(`Scan target limit exceeded (>${maxHosts} hosts). Narrow the range or raise KIKU_LAN_SCAN_MAX_HOSTS.`);
+      }
+      const first = prefix <= 30 ? network + 1 : network;
+      const last = prefix <= 30 ? network + size - 2 : network + size - 1;
+      for (let ip = first; ip <= last; ip++) pushIp(ip >>> 0);
+    } else if (spec.includes('-')) {
+      const [startStr, endStr] = spec.split('-');
+      const startOctets = parseIpv4(startStr);
+      const endOctets = parseIpv4(endStr);
+      if (!startOctets || !endOctets) {
+        throw new Error(`Invalid IP range "${spec}" (expected a.b.c.d-e.f.g.h)`);
+      }
+      const start = ipv4ToUint32(startOctets);
+      const end = ipv4ToUint32(endOctets);
+      if (end < start) throw new Error(`Invalid IP range "${spec}" (start is after end)`);
+      const count = end - start + 1;
+      planned += count;
+      if (planned > maxHosts) {
+        throw new Error(`Scan target limit exceeded (>${maxHosts} hosts). Narrow the range or raise KIKU_LAN_SCAN_MAX_HOSTS.`);
+      }
+      for (let ip = start; ip <= end; ip++) pushIp(ip >>> 0);
+    } else {
+      const octets = parseIpv4(spec);
+      if (!octets) throw new Error(`Invalid IP address "${spec}"`);
+      planned += 1;
+      pushIp(ipv4ToUint32(octets));
+    }
+  }
+
+  return out;
+}
+
+function assertAllPrivate(hosts) {
+  const offenders = hosts.filter(h => {
+    const octets = parseIpv4(h);
+    if (!octets) return true;
+    if (octets[0] === 127) return false;
+    return !isPrivateIPv4(h);
+  });
+  if (offenders.length > 0) {
+    throw new Error(`LAN discovery only scans private network ranges (RFC1918). Rejected: ${offenders.slice(0, 5).join(', ')}`);
+  }
+}
+
+function abortError() {
+  const error = new Error('LAN scan cancelled');
+  error.name = 'AbortError';
+  return error;
+}
+
+function defaultTcpProbe(host, port, timeoutMs, signal) {
+  return new Promise(resolve => {
+    if (signal?.aborted) {
+      resolve(false);
+      return;
+    }
+    const socket = new net.Socket();
+    let settled = false;
+    const onAbort = () => done(false);
+    const done = result => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener('abort', onAbort);
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => done(true));
+    socket.once('timeout', () => done(false));
+    socket.once('error', () => done(false));
+    signal?.addEventListener('abort', onAbort, { once: true });
+    socket.connect(port, host);
+  });
+}
+
+export async function classifyModelsEndpoint({ host, port, timeoutMs = 2500, signal, fetchImpl = fetch }) {
+  const started = performance.now();
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  const fetchSignal = signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal;
+  const record = {
+    host,
+    port,
+    url: `http://${host}:${port}/v1`,
+    reachable: false,
+    serverType: 'openai-compatible',
+    serverName: SERVER_TYPE_LABELS['openai-compatible'],
+    models: [],
+    modelCount: 0,
+    authRequired: false,
+    latencyMs: null,
+  };
+
+  let modelsPayload = null;
+  try {
+    const res = await fetchImpl(`http://${host}:${port}/v1/models`, {
+      headers: { Accept: 'application/json' },
+      signal: fetchSignal,
+    });
+    if (res.status === 401 || res.status === 403) {
+      record.reachable = true;
+      record.authRequired = true;
+      record.latencyMs = Math.round(performance.now() - started);
+      return record;
+    }
+    if (res.ok) {
+      const json = await res.json().catch(() => null);
+      if (json && Array.isArray(json.data)) {
+        record.reachable = true;
+        modelsPayload = json;
+        record.models = json.data.map(m => m?.id).filter(Boolean);
+      }
+    }
+  } catch {
+    return record;
+  }
+
+  const ownedBy = (modelsPayload?.data || []).map(m => String(m?.owned_by || '').toLowerCase()).join(' ');
+  if (ownedBy.includes('lmstudio')) record.serverType = 'lmstudio';
+  else if (ownedBy.includes('vllm')) record.serverType = 'vllm';
+  else {
+    try {
+      const tagsRes = await fetchImpl(`http://${host}:${port}/api/tags`, {
+        headers: { Accept: 'application/json' },
+        signal: fetchSignal,
+      });
+      if (tagsRes.ok) {
+        const tags = await tagsRes.json().catch(() => null);
+        if (tags && Array.isArray(tags.models)) {
+          record.reachable = true;
+          record.serverType = 'ollama';
+          if (record.models.length === 0) {
+            record.models = tags.models.map(m => m?.name || m?.model).filter(Boolean);
+          }
+        }
+      }
+    } catch {}
+  }
+
+  if (record.reachable && record.serverType === 'openai-compatible') {
+    try {
+      const v0Res = await fetchImpl(`http://${host}:${port}/api/v0/models`, {
+        headers: { Accept: 'application/json' },
+        signal: fetchSignal,
+      });
+      if (v0Res.ok) {
+        const v0 = await v0Res.json().catch(() => null);
+        if (v0 && Array.isArray(v0.data)) {
+          record.serverType = 'lmstudio';
+          if (record.models.length === 0) {
+            record.models = v0.data.map(m => m?.id).filter(Boolean);
+          }
+        }
+      }
+    } catch {}
+  }
+
+  if (record.reachable && record.serverType === 'openai-compatible') {
+    try {
+      const versionRes = await fetchImpl(`http://${host}:${port}/version`, {
+        headers: { Accept: 'application/json' },
+        signal: fetchSignal,
+      });
+      if (versionRes.ok) {
+        const version = await versionRes.json().catch(() => null);
+        if (version && version.version) {
+          record.serverType = 'vllm';
+        }
+      }
+    } catch {}
+  }
+
+  record.serverName = SERVER_TYPE_LABELS[record.serverType] || record.serverType;
+  record.modelCount = record.models.length;
+  record.latencyMs = Math.round(performance.now() - started);
+  return record;
+}
+
+async function runPool(items, concurrency, worker, signal) {
+  const results = [];
+  let cursor = 0;
+  const lanes = Array.from({ length: Math.max(1, Math.min(concurrency, items.length)) }, async () => {
+    while (cursor < items.length) {
+      if (signal?.aborted) throw abortError();
+      const index = cursor++;
+      results[index] = await worker(items[index], index);
+    }
+  });
+  await Promise.all(lanes);
+  return results;
+}
+
+let scanCache = null;
+
+export function clearLanScanCache() {
+  scanCache = null;
+}
+
+export async function scanLan({
+  ports = DEFAULT_LLM_PORTS,
+  timeoutMs = 900,
+  probeTimeoutMs = 2500,
+  concurrency = 128,
+  subnets = null,
+  extraHosts = [],
+  maxHosts = Number(process.env.KIKU_LAN_SCAN_MAX_HOSTS) || DEFAULT_MAX_SCAN_HOSTS,
+  connector = defaultTcpProbe,
+  prober = classifyModelsEndpoint,
+  now = Date.now,
+  force = false,
+  signal = null,
+} = {}) {
+  if (signal?.aborted) throw abortError();
+  const portList = [...new Set((Array.isArray(ports) ? ports : DEFAULT_LLM_PORTS).map(Number))].filter(
+    p => Number.isInteger(p) && p >= 1 && p <= 65535
+  );
+  if (portList.length === 0) throw new Error('At least one valid port is required');
+
+  const subnetList = subnets && subnets.length > 0 ? subnets : getLanCandidateSubnets().map(s => s.cidr);
+  const detectedHosts = expandTargets(subnetList, { maxHosts });
+  const hostList = [...new Set(['127.0.0.1', ...detectedHosts, ...extraHosts.map(String)])];
+  assertAllPrivate(hostList);
+
+  const cacheKey = JSON.stringify({ ports: portList, hosts: hostList });
+  if (!force && scanCache && scanCache.key === cacheKey && now() - scanCache.at < CACHE_TTL_MS) {
+    return { ...scanCache.result, cached: true };
+  }
+
+  const targets = [];
+  for (const host of hostList) {
+    for (const port of portList) {
+      targets.push({ host, port });
+    }
+  }
+
+  const started = now();
+  const openTargets = [];
+  await runPool(targets, concurrency, async ({ host, port }) => {
+    const isOpen = await connector(host, port, timeoutMs, signal);
+    if (isOpen) openTargets.push({ host, port });
+  }, signal);
+  openTargets.sort((a, b) => a.host.localeCompare(b.host, undefined, { numeric: true }) || a.port - b.port);
+  if (signal?.aborted) throw abortError();
+
+  const endpoints = await runPool(openTargets, Math.min(concurrency, 16), async ({ host, port }) => {
+    try {
+      return await prober({ host, port, timeoutMs: probeTimeoutMs, signal });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      return { host, port, url: `http://${host}:${port}/v1`, reachable: false, serverType: 'openai-compatible', serverName: 'OpenAI-Compatible', models: [], modelCount: 0, authRequired: false, latencyMs: null };
+    }
+  }, signal);
+
+  const found = endpoints
+    .filter(e => e && e.reachable)
+    .sort((a, b) => (a.latencyMs ?? 9e9) - (b.latencyMs ?? 9e9) || a.host.localeCompare(b.host, undefined, { numeric: true }));
+
+  const result = {
+    scannedAt: new Date(started).toISOString(),
+    subnets: subnetList,
+    hostsScanned: hostList.length,
+    ports: portList,
+    targetsScanned: targets.length,
+    openPorts: openTargets.length,
+    durationMs: now() - started,
+    endpoints: found,
+  };
+
+  scanCache = { key: cacheKey, at: now(), result };
+  return { ...result, cached: false };
+}

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 || ''));