kiku-agent 1.0.11 → 1.2.0

package/server/agent/modelManager.js

@@ -1,20 +1,27 @@
-import { normalizeProviderModel } from './config.js';
-
-const NON_CHAT_MODEL = /(embed|embedding|rerank|whisper|tts|clip)/i;
+import { normalizeProviderModel, matchModelIdentifier } from './config.js';
+
+const NON_CHAT_MODEL = /(embed|embedding|rerank|whisper|tts|clip)/i;
 
 export class ModelManager {
-  constructor(client, options = {}) {
+  constructor(client, options = {}) {
     if (!client) throw new Error('ModelManager requires an LLM client.');
     this.client = client;
-    this.requestedModel = options.requestedModel || client.model;
-    this.fallbackModel = options.fallbackModel || null;
-    this.fallbackModels = Array.isArray(options.fallbackModels) ? options.fallbackModels : [];
+    this.requestedModel = options.requestedModel || client.model;
+    this.fallbackModel = options.fallbackModel || null;
+    this.fallbackModels = Array.isArray(options.fallbackModels) ? options.fallbackModels : [];
     this.lastResolution = null;
   }
 
   async inspect() {
     const health = await this.client.checkConnection();
     const models = health.models || [];
+    const isReady = health.connected && models.length > 0 && (
+      models.includes(this.client.model) ||
+      models.some(m => matchModelIdentifier(this.client.model, m)) ||
+      Boolean(health.activeLoadedModel && models.includes(health.activeLoadedModel)) ||
+      Boolean(health.activeModel && models.includes(health.activeModel))
+    );
+
     return {
       ...health,
       models,
@@ -23,28 +30,40 @@ export class ModelManager {
         ? 'server_offline'
         : models.length === 0
           ? 'server_online_no_models'
-          : models.includes(this.client.model)
+          : isReady
             ? 'ready'
             : 'requested_model_missing',
     };
   }
 
-  select(model, availableModels = []) {
-    const requested = normalizeProviderModel(this.client.provider, String(model || '').trim());
-    if (!requested) throw new Error('A model ID is required.');
-    if (availableModels.length > 0 && !availableModels.includes(requested)) {
-      throw new Error(`Model is not available: ${requested}`);
-    }
+  select(model, availableModels = []) {
+    const rawInput = String(model || '').trim();
+    if (!rawInput) throw new Error('A model ID is required.');
+    const requested = normalizeProviderModel(this.client.provider, rawInput);
     if (NON_CHAT_MODEL.test(requested)) {
       throw new Error(`Model does not appear to support chat: ${requested}`);
     }
-    if (typeof this.client.setModel === 'function') {
-      this.client.setModel(requested);
-    } else {
-      this.client.model = requested;
-    }
-    this.requestedModel = requested;
-    return requested;
+
+    let targetModel = requested;
+    if (availableModels.length > 0) {
+      const exact = availableModels.find(m => m === requested || m === rawInput);
+      const fuzzy = availableModels.find(m => matchModelIdentifier(requested, m) || matchModelIdentifier(rawInput, m));
+      if (exact) {
+        targetModel = exact;
+      } else if (fuzzy) {
+        targetModel = fuzzy;
+      } else {
+        throw new Error(`Model is not available: ${requested}`);
+      }
+    }
+
+    if (typeof this.client.setModel === 'function') {
+      this.client.setModel(targetModel);
+    } else {
+      this.client.model = targetModel;
+    }
+    this.requestedModel = targetModel;
+    return targetModel;
   }
 
   async resolve(options = {}) {
@@ -57,33 +76,54 @@ export class ModelManager {
       return this._record({ state: 'server_online_no_models', connected: true, models, error: `${this.client.providerName || 'LLM server'} is online but no model is loaded.` });
     }
 
-    const requested = options.requestedModel || this.requestedModel;
-    const exact = models.find(id => id === requested);
-    const configuredFallback = models.find(id => id === (options.fallbackModel || this.fallbackModel));
-    const providerRecommendations = this.client.getProviderInfo?.().recommendedModels || [];
-    const fallbackCandidates = [
-      ...(Array.isArray(options.fallbackModels) ? options.fallbackModels : this.fallbackModels),
-      ...providerRecommendations.map(model => model.id),
-    ];
-    const recommendedFallback = fallbackCandidates
-      .map(candidate => models.find(id => id === candidate))
-      .find(Boolean);
-    const gemma = this.client.provider === 'lmstudio'
-      ? models.find(id => /gemma/i.test(id) && !NON_CHAT_MODEL.test(id))
-      : null;
-    const chatFallback = models.find(id => !NON_CHAT_MODEL.test(id));
-    const selected = exact || configuredFallback || recommendedFallback || gemma || chatFallback;
+    const requestedRaw = options.requestedModel || this.requestedModel || this.client.model;
+    const requested = normalizeProviderModel(this.client.provider, requestedRaw);
+
+   
+    const activeLoaded = health.activeLoadedModel;
+
+   
+    const exact = models.find(id => id === requested || id === requestedRaw);
+
+    
+    const fuzzyRequested = models.find(id => matchModelIdentifier(requested, id) || matchModelIdentifier(requestedRaw, id));
+
+   
+    const configuredFallback = models.find(id => id === (options.fallbackModel || this.fallbackModel));
+
+   
+    const providerRecommendations = this.client.getProviderInfo?.().recommendedModels || [];
+    const fallbackCandidates = [
+      ...(Array.isArray(options.fallbackModels) ? options.fallbackModels : this.fallbackModels),
+      ...providerRecommendations.map(model => model.id),
+    ];
+    const recommendedFallback = fallbackCandidates
+      .map(candidate => models.find(id => id === candidate || matchModelIdentifier(candidate, id)))
+      .find(Boolean);
+
+  
+    const gemma = this.client.provider === 'lmstudio'
+      ? (activeLoaded && /gemma/i.test(activeLoaded) ? activeLoaded : models.find(id => /gemma/i.test(id) && !NON_CHAT_MODEL.test(id)))
+      : null;
+
+    
+    const chatFallback = (activeLoaded && !NON_CHAT_MODEL.test(activeLoaded))
+      ? activeLoaded
+      : models.find(id => !NON_CHAT_MODEL.test(id));
+
+    const selected = exact || fuzzyRequested || (activeLoaded && matchModelIdentifier(requested, activeLoaded) ? activeLoaded : null) || configuredFallback || recommendedFallback || activeLoaded || gemma || chatFallback;
     if (!selected) {
       return this._record({ state: 'no_chat_model', connected: true, models, error: 'No chat-capable model was found.' });
     }
+
     this.client.model = selected;
     return this._record({
-      state: exact ? 'ready' : 'fallback_selected',
+      state: (exact || fuzzyRequested) ? 'ready' : 'fallback_selected',
       connected: true,
       models,
       selectedModel: selected,
       requestedModel: requested,
-      usedFallback: !exact,
+      usedFallback: !(exact || (fuzzyRequested && matchModelIdentifier(requested, selected))),
     });
   }
 

package/server/agent/profiles.js

@@ -0,0 +1,178 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PROFILES_FILE, KIKU_DATA_DIR } from './appPaths.js';
+
+export const BUILTIN_PROFILES = {
+  default: {
+    name: 'default',
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    thinking: 'show',
+    temperature: 0.3,
+    description: 'Local Gemma 4 e4b via LM Studio (free, private, offline)',
+    isBuiltIn: true
+  },
+  fast: {
+    name: 'fast',
+    provider: 'groq',
+    model: 'openai/gpt-oss-20b',
+    thinking: 'hide',
+    temperature: 0.2,
+    description: 'Ultra-fast inference on Groq LPU (low latency)',
+    isBuiltIn: true
+  },
+  'deep-reasoning': {
+    name: 'deep-reasoning',
+    provider: 'deepseek',
+    model: 'deepseek-v4-flash',
+    thinking: 'show',
+    temperature: 0.3,
+    description: 'DeepSeek V4 with full reasoning traces and CoT',
+    isBuiltIn: true
+  },
+  cloud: {
+    name: 'cloud',
+    provider: 'openai',
+    model: 'gpt-5.6-luna',
+    thinking: 'show',
+    temperature: 0.3,
+    description: 'OpenAI Cloud flagship multilingual agent tier',
+    isBuiltIn: true
+  },
+  gemini: {
+    name: 'gemini',
+    provider: 'gemini',
+    model: 'gemini-3.7-flash',
+    thinking: 'show',
+    temperature: 0.3,
+    description: 'Google Gemini 3.7 Flash multilingual reasoning',
+    isBuiltIn: true
+  }
+};
+
+export function loadProfiles() {
+  try {
+    if (fs.existsSync(PROFILES_FILE)) {
+      const raw = fs.readFileSync(PROFILES_FILE, 'utf-8');
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === 'object') {
+        const userProfiles = parsed.profiles || {};
+        return {
+          activeProfile: parsed.activeProfile || 'default',
+          profiles: {
+            ...BUILTIN_PROFILES,
+            ...userProfiles
+          }
+        };
+      }
+    }
+  } catch {}
+
+  return {
+    activeProfile: 'default',
+    profiles: { ...BUILTIN_PROFILES }
+  };
+}
+
+export function saveProfiles(data) {
+  try {
+    if (!fs.existsSync(KIKU_DATA_DIR)) {
+      fs.mkdirSync(KIKU_DATA_DIR, { recursive: true });
+    }
+    const customProfiles = {};
+    for (const [key, val] of Object.entries(data.profiles || {})) {
+      if (!BUILTIN_PROFILES[key] || val.customized) {
+        customProfiles[key] = val;
+      }
+    }
+    const toWrite = {
+      activeProfile: data.activeProfile || 'default',
+      profiles: customProfiles,
+      updatedAt: new Date().toISOString()
+    };
+    fs.writeFileSync(PROFILES_FILE, JSON.stringify(toWrite, null, 2), 'utf-8');
+    return true;
+  } catch (err) {
+    console.error('Failed to save profiles to disk:', err.message);
+    return false;
+  }
+}
+
+export function getProfile(name) {
+  if (!name || typeof name !== 'string') return null;
+  const normalized = name.toLowerCase().trim();
+  const data = loadProfiles();
+  return data.profiles[normalized] || null;
+}
+
+export function getActiveProfile() {
+  const data = loadProfiles();
+  const activeName = data.activeProfile || 'default';
+  const profile = data.profiles[activeName] || BUILTIN_PROFILES.default;
+  return {
+    ...profile,
+    name: activeName
+  };
+}
+
+export function setActiveProfile(name) {
+  if (!name || typeof name !== 'string') return false;
+  const normalized = name.toLowerCase().trim();
+  const data = loadProfiles();
+  if (!data.profiles[normalized]) {
+    throw new Error(`Profile "${name}" does not exist. Run /profile list to see available profiles.`);
+  }
+  data.activeProfile = normalized;
+  saveProfiles(data);
+  return data.profiles[normalized];
+}
+
+export function createOrUpdateProfile(name, config) {
+  if (!name || typeof name !== 'string') {
+    throw new Error('Profile name is required');
+  }
+  const normalized = name.toLowerCase().trim();
+  const data = loadProfiles();
+
+  const existing = data.profiles[normalized] || {};
+  data.profiles[normalized] = {
+    ...existing,
+    name: normalized,
+    provider: config.provider || existing.provider || 'lmstudio',
+    model: config.model || existing.model || 'google/gemma-4-e4b',
+    thinking: config.thinking || existing.thinking || 'show',
+    temperature: config.temperature !== undefined ? Number(config.temperature) : (existing.temperature ?? 0.3),
+    description: config.description || existing.description || `Custom profile ${normalized}`,
+    customized: true,
+    updatedAt: new Date().toISOString()
+  };
+
+  saveProfiles(data);
+  return data.profiles[normalized];
+}
+
+export function deleteProfile(name) {
+  if (!name || typeof name !== 'string') return false;
+  const normalized = name.toLowerCase().trim();
+  if (BUILTIN_PROFILES[normalized]) {
+    throw new Error(`Cannot delete built-in profile "${name}".`);
+  }
+  const data = loadProfiles();
+  if (!data.profiles[normalized]) return false;
+
+  delete data.profiles[normalized];
+  if (data.activeProfile === normalized) {
+    data.activeProfile = 'default';
+  }
+  saveProfiles(data);
+  return true;
+}
+
+export function listProfiles() {
+  const data = loadProfiles();
+  return Object.values(data.profiles).map(p => ({
+    id: p.name,
+    ...p,
+    isActive: p.name === data.activeProfile
+  }));
+}

package/server/agent/publicTools.js

@@ -0,0 +1,22 @@
+
+export const PUBLIC_REMOTE_TOOL_NAMES = Object.freeze(new Set([
+  'global_search',
+  'search_works',
+  'get_work_detail',
+  'get_character_roles',
+  'search_discography',
+  'get_profile_and_fandom',
+  'get_awards',
+  'get_brand_endorsements',
+  'get_career_timeline',
+  'get_social_feed',
+  'get_gallery_photos',
+  'get_quotes',
+  'get_music_videos',
+  'get_media_links',
+  'search_youtube',
+  'web_search',
+  'web_extract',
+  'fetch_webpage',
+  'fetch_api',
+]));

package/server/agent/queryDetails.js

@@ -5,13 +5,32 @@ const DETAIL_VIEWS = new Set([
   'markdown', 'json', 'text', 'raw', 'session', 'transcript', 'history'
 ]);
 
+const DETAIL_VIEW_ALIASES = Object.freeze({
+  think: 'thinking',
+  thought: 'thinking',
+  thoughts: 'thinking',
+  reasoning: 'thinking',
+  ans: 'answer',
+  response: 'answer',
+  result: 'answer',
+  toolcalls: 'tools',
+  tool_calls: 'tools',
+  calls: 'tools',
+  tool_call: 'tool',
+  md: 'markdown',
+  txt: 'text',
+  sess: 'session',
+});
+
 export function parseDetailsRequest(reference = '') {
   const tokens = String(reference || '').trim().split(/\s+/).filter(Boolean);
   let queryNumber = null;
   let isSession = false;
 
   const first = (tokens[0] || '').toLowerCase();
-  if (first === 'session' || first === 'transcript' || first === 'history') {
+  const normalizedFirst = DETAIL_VIEW_ALIASES[first] || first;
+
+  if (normalizedFirst === 'session' || normalizedFirst === 'transcript' || normalizedFirst === 'history') {
     isSession = true;
     tokens.shift();
   } else if (/^q?\d+$/i.test(tokens[0])) {
@@ -20,10 +39,13 @@ export function parseDetailsRequest(reference = '') {
     tokens.shift();
   }
 
-  let view = (tokens.shift() || (isSession ? 'markdown' : 'answer')).toLowerCase();
+  let rawView = (tokens.shift() || (isSession ? 'markdown' : 'answer')).toLowerCase();
+  let view = DETAIL_VIEW_ALIASES[rawView] || rawView;
+
   if (view === 'session' || view === 'transcript' || view === 'history') {
     isSession = true;
-    view = (tokens.shift() || 'markdown').toLowerCase();
+    const nextRaw = (tokens.shift() || 'markdown').toLowerCase();
+    view = DETAIL_VIEW_ALIASES[nextRaw] || nextRaw;
   }
 
   if (!DETAIL_VIEWS.has(view)) {
@@ -95,14 +117,15 @@ export function copyToClipboard(text) {
 
   try {
     if (platform === 'win32') {
-      const proc = spawnSync('clip', [], { input: text, encoding: 'utf-8', windowsHide: true });
-      if (proc.status === 0) return true;
-      const ps = spawnSync('powershell.exe', ['-NoProfile', '-Command', '$input | Set-Clipboard'], {
+      const ps = spawnSync('powershell.exe', ['-NoProfile', '-Command', '[Console]::InputEncoding = [System.Text.Encoding]::UTF8; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([System.Console]::In.ReadToEnd())'], {
         input: text,
         encoding: 'utf-8',
         windowsHide: true,
       });
-      return ps.status === 0;
+      if (ps.status === 0) return true;
+
+      const proc = spawnSync('clip', [], { input: text, encoding: 'utf-8', windowsHide: true });
+      if (proc.status === 0) return true;
     }
     if (platform === 'darwin') {
       const proc = spawnSync('pbcopy', [], { input: text, encoding: 'utf-8' });
@@ -123,8 +146,38 @@ export function copyToClipboard(text) {
   return false;
 }
 
+export function readFromClipboard() {
+  const platform = process.platform;
+  try {
+    if (platform === 'win32') {
+      const ps = spawnSync('powershell.exe', ['-NoProfile', '-Command', '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Get-Clipboard -Raw'], {
+        encoding: 'utf-8',
+        windowsHide: true,
+        timeout: 1500,
+      });
+      if (ps.status === 0 && typeof ps.stdout === 'string') return ps.stdout;
+    } else if (platform === 'darwin') {
+      const proc = spawnSync('pbpaste', [], { encoding: 'utf-8', timeout: 1500 });
+      if (proc.status === 0 && typeof proc.stdout === 'string') return proc.stdout;
+    } else {
+      const tools = [
+        { cmd: 'wl-paste', args: ['--no-newline'] },
+        { cmd: 'xclip', args: ['-selection', 'clipboard', '-o'] },
+        { cmd: 'xsel', args: ['--clipboard', '--output'] },
+      ];
+      for (const t of tools) {
+        try {
+          const proc = spawnSync(t.cmd, t.args, { encoding: 'utf-8', timeout: 1500 });
+          if (proc.status === 0 && typeof proc.stdout === 'string') return proc.stdout;
+        } catch {}
+      }
+    }
+  } catch {}
+  return '';
+}
+
 export function getCopyableContent(details, request = {}, session = null) {
-  const isSessionReq = request.isSession || (!details && session);
+  const isSessionReq = Boolean(request.isSession);
   const view = request.view || 'answer';
 
   if (isSessionReq && session) {
@@ -135,6 +188,13 @@ export function getCopyableContent(details, request = {}, session = null) {
         type: 'session_json',
       };
     }
+    if (view === 'html' || view === 'web') {
+      return {
+        title: `Full Session HTML • ${session.id}`,
+        text: typeof session.getTranscriptHtml === 'function' ? session.getTranscriptHtml() : '',
+        type: 'session_html',
+      };
+    }
     if (view === 'text' || view === 'raw') {
       return {
         title: `Full Session Text • ${session.id}`,