kiku-agent 1.3.2 → 1.3.4

package/server/supabase_migration_prefix.sql

@@ -0,0 +1,102 @@
+DO $$ 
+BEGIN
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'api_keys') 
+       AND NOT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'jujingyi_kikuuu_api_keys') THEN
+        ALTER TABLE public.api_keys RENAME TO jujingyi_kikuuu_api_keys;
+    ELSIF NOT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'jujingyi_kikuuu_api_keys') THEN
+        CREATE TABLE public.jujingyi_kikuuu_api_keys (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            key_prefix VARCHAR(32) NOT NULL,              
+            key_hash VARCHAR(64) UNIQUE NOT NULL,           
+            tier VARCHAR(32) DEFAULT 'developer_vip',      
+            rate_limit_per_min INT DEFAULT 1000,           
+            is_active BOOLEAN DEFAULT TRUE,           
+            created_at TIMESTAMPTZ DEFAULT NOW(),
+            last_used_at TIMESTAMPTZ,
+            expires_at TIMESTAMPTZ,                        
+            revoked_reason TEXT
+        );
+    END IF;
+END $$;
+
+
+DO $$ 
+BEGIN
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'quiz_sessions') 
+       AND NOT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'jujingyi_kikuuu_quiz_sessions') THEN
+        ALTER TABLE public.quiz_sessions RENAME TO jujingyi_kikuuu_quiz_sessions;
+    ELSIF NOT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'jujingyi_kikuuu_quiz_sessions') THEN
+        CREATE TABLE public.jujingyi_kikuuu_quiz_sessions (
+            session_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            challenge_token VARCHAR(255) UNIQUE NOT NULL,
+            is_completed BOOLEAN DEFAULT FALSE,
+            is_claimed BOOLEAN DEFAULT FALSE,
+            created_at TIMESTAMPTZ DEFAULT NOW(),
+            expires_at TIMESTAMPTZ DEFAULT (NOW() + INTERVAL '15 minutes')
+        );
+    END IF;
+
+  
+    IF EXISTS (
+        SELECT 1 FROM information_schema.columns 
+        WHERE table_schema = 'public' AND table_name = 'jujingyi_kikuuu_quiz_sessions' 
+          AND column_name = 'challenge_token' AND character_maximum_length < 255
+    ) THEN
+        ALTER TABLE public.jujingyi_kikuuu_quiz_sessions ALTER COLUMN challenge_token TYPE VARCHAR(255);
+    END IF;
+END $$;
+
+
+DO $$ 
+BEGIN
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'api_request_logs') 
+       AND NOT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'jujingyi_kikuuu_api_request_logs') THEN
+        ALTER TABLE public.api_request_logs RENAME TO jujingyi_kikuuu_api_request_logs;
+    ELSIF NOT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'jujingyi_kikuuu_api_request_logs') THEN
+        CREATE TABLE public.jujingyi_kikuuu_api_request_logs (
+            id BIGSERIAL PRIMARY KEY,
+            ip_address VARCHAR(45) NOT NULL,
+            endpoint VARCHAR(255) NOT NULL,
+            method VARCHAR(10) NOT NULL,
+            status_code INT NOT NULL,
+            response_time_ms NUMERIC(8,2),
+            key_prefix VARCHAR(32),
+            created_at TIMESTAMPTZ DEFAULT NOW()
+        );
+    END IF;
+END $$;
+
+
+ALTER TABLE public.jujingyi_kikuuu_api_keys ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.jujingyi_kikuuu_quiz_sessions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.jujingyi_kikuuu_api_request_logs ENABLE ROW LEVEL SECURITY;
+
+
+DO $$ 
+BEGIN
+   
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE tablename = 'jujingyi_kikuuu_api_keys' AND policyname = 'Service Role Access on jujingyi_kikuuu_api_keys') THEN
+        CREATE POLICY "Service Role Access on jujingyi_kikuuu_api_keys" 
+        ON public.jujingyi_kikuuu_api_keys FOR ALL USING (auth.role() = 'service_role');
+    END IF;
+
+ 
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE tablename = 'jujingyi_kikuuu_quiz_sessions' AND policyname = 'Service Role Access on jujingyi_kikuuu_quiz_sessions') THEN
+        CREATE POLICY "Service Role Access on jujingyi_kikuuu_quiz_sessions" 
+        ON public.jujingyi_kikuuu_quiz_sessions FOR ALL USING (auth.role() = 'service_role');
+    END IF;
+
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE tablename = 'jujingyi_kikuuu_api_request_logs' AND policyname = 'Service Role Access on jujingyi_kikuuu_api_request_logs') THEN
+        CREATE POLICY "Service Role Access on jujingyi_kikuuu_api_request_logs" 
+        ON public.jujingyi_kikuuu_api_request_logs FOR ALL USING (auth.role() = 'service_role');
+    END IF;
+END $$;
+
+
+ALTER INDEX IF EXISTS idx_api_keys_hash RENAME TO idx_jujingyi_kikuuu_api_keys_hash;
+ALTER INDEX IF EXISTS idx_quiz_sessions_token RENAME TO idx_jujingyi_kikuuu_quiz_sessions_token;
+ALTER INDEX IF EXISTS idx_api_logs_ip_time RENAME TO idx_jujingyi_kikuuu_api_logs_ip_time;
+
+CREATE INDEX IF NOT EXISTS idx_jujingyi_kikuuu_api_keys_hash ON public.jujingyi_kikuuu_api_keys (key_hash) WHERE is_active = TRUE;
+CREATE INDEX IF NOT EXISTS idx_jujingyi_kikuuu_quiz_sessions_token ON public.jujingyi_kikuuu_quiz_sessions (challenge_token) WHERE is_claimed = FALSE;
+CREATE INDEX IF NOT EXISTS idx_jujingyi_kikuuu_api_logs_ip_time ON public.jujingyi_kikuuu_api_request_logs (ip_address, created_at DESC);

package/server/supabase_schema.sql

@@ -1,4 +1,4 @@
-CREATE TABLE IF NOT EXISTS public.api_keys (
+CREATE TABLE IF NOT EXISTS public.jujingyi_kikuuu_api_keys (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     key_prefix VARCHAR(32) NOT NULL,              
     key_hash VARCHAR(64) UNIQUE NOT NULL,           
@@ -12,7 +12,7 @@ CREATE TABLE IF NOT EXISTS public.api_keys (
 );
 
 
-CREATE TABLE IF NOT EXISTS public.quiz_sessions (
+CREATE TABLE IF NOT EXISTS public.jujingyi_kikuuu_quiz_sessions (
     session_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     challenge_token VARCHAR(64) UNIQUE NOT NULL,
     is_completed BOOLEAN DEFAULT FALSE,
@@ -22,7 +22,7 @@ CREATE TABLE IF NOT EXISTS public.quiz_sessions (
 );
 
 
-CREATE TABLE IF NOT EXISTS public.api_request_logs (
+CREATE TABLE IF NOT EXISTS public.jujingyi_kikuuu_api_request_logs (
     id BIGSERIAL PRIMARY KEY,
     ip_address VARCHAR(45) NOT NULL,
     endpoint VARCHAR(255) NOT NULL,
@@ -34,30 +34,30 @@ CREATE TABLE IF NOT EXISTS public.api_request_logs (
 );
 
 
-ALTER TABLE public.api_keys ENABLE ROW LEVEL SECURITY;
-ALTER TABLE public.quiz_sessions ENABLE ROW LEVEL SECURITY;
-ALTER TABLE public.api_request_logs ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.jujingyi_kikuuu_api_keys ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.jujingyi_kikuuu_quiz_sessions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.jujingyi_kikuuu_api_request_logs ENABLE ROW LEVEL SECURITY;
 
 
 DO $$ 
 BEGIN
-    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE policyname = 'Service Role Access on api_keys') THEN
-        CREATE POLICY "Service Role Access on api_keys" 
-        ON public.api_keys FOR ALL USING (auth.role() = 'service_role');
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE policyname = 'Service Role Access on jujingyi_kikuuu_api_keys') THEN
+        CREATE POLICY "Service Role Access on jujingyi_kikuuu_api_keys" 
+        ON public.jujingyi_kikuuu_api_keys FOR ALL USING (auth.role() = 'service_role');
     END IF;
 
-    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE policyname = 'Service Role Access on quiz_sessions') THEN
-        CREATE POLICY "Service Role Access on quiz_sessions" 
-        ON public.quiz_sessions FOR ALL USING (auth.role() = 'service_role');
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE policyname = 'Service Role Access on jujingyi_kikuuu_quiz_sessions') THEN
+        CREATE POLICY "Service Role Access on jujingyi_kikuuu_quiz_sessions" 
+        ON public.jujingyi_kikuuu_quiz_sessions FOR ALL USING (auth.role() = 'service_role');
     END IF;
 
-    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE policyname = 'Service Role Access on api_request_logs') THEN
-        CREATE POLICY "Service Role Access on api_request_logs" 
-        ON public.api_request_logs FOR ALL USING (auth.role() = 'service_role');
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE policyname = 'Service Role Access on jujingyi_kikuuu_api_request_logs') THEN
+        CREATE POLICY "Service Role Access on jujingyi_kikuuu_api_request_logs" 
+        ON public.jujingyi_kikuuu_api_request_logs FOR ALL USING (auth.role() = 'service_role');
     END IF;
 END $$;
 
 
-CREATE INDEX IF NOT EXISTS idx_api_keys_hash ON public.api_keys (key_hash) WHERE is_active = TRUE;
-CREATE INDEX IF NOT EXISTS idx_quiz_sessions_token ON public.quiz_sessions (challenge_token) WHERE is_claimed = FALSE;
-CREATE INDEX IF NOT EXISTS idx_api_logs_ip_time ON public.api_request_logs (ip_address, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_jujingyi_kikuuu_api_keys_hash ON public.jujingyi_kikuuu_api_keys (key_hash) WHERE is_active = TRUE;
+CREATE INDEX IF NOT EXISTS idx_jujingyi_kikuuu_quiz_sessions_token ON public.jujingyi_kikuuu_quiz_sessions (challenge_token) WHERE is_claimed = FALSE;
+CREATE INDEX IF NOT EXISTS idx_jujingyi_kikuuu_api_logs_ip_time ON public.jujingyi_kikuuu_api_request_logs (ip_address, created_at DESC);

package/server/web-chat/core/connection.js

@@ -1,218 +1,179 @@
-import fs from 'node:fs';
-import { createHash } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { LLMClient } from '../../agent/llmClient.js';
-import { KikuAgent } from '../../agent/agentCore.js';
-import { AgentMemory } from '../../agent/memory.js';
-import { ModelManager } from '../../agent/modelManager.js';
-import { config, getProviderBaseUrl, getPersistedActiveProvider } from '../../agent/config.js';
-import { PUBLIC_REMOTE_TOOL_NAMES } from '../../agent/publicTools.js';
-
-export const webAgentCache = new Map();
-export let sharedWebMemory = new AgentMemory({ persistence: false });
-export let currentAgent = null;
-const MAX_WEB_AGENT_SESSIONS = 24;
-
-export function setSharedWebMemory(mem) {
-  if (mem) sharedWebMemory = mem;
-}
-
-export function setCurrentAgent(agent) {
-  if (agent) {
-    currentAgent = agent;
-    if (agent.memory) sharedWebMemory = agent.memory;
-  }
-}
-
-export function normalizeWebSessionId(value) {
-  const normalized = String(value || '').trim().replace(/[^a-zA-Z0-9_-]+/g, '_').slice(0, 100);
-  return normalized || null;
-}
-
-export function credentialFingerprint(value) {
-  if (!value) return 'no-key';
-  return createHash('sha256').update(String(value)).digest('hex').slice(0, 12);
-}
-
-export function computeSessionHash(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return '';
-  const payload = messages.map(m => (m.role || '') + ':' + (m.parts?.[0]?.content || m.text || '')).join('|');
-  return createHash('sha256').update(payload).digest('hex').slice(0, 16);
-}
-
-export function getWebAgentCacheKey({ sessionId, provider, model, apiKey }) {
-  if (!sessionId) return null;
-  return [sessionId, provider || 'lmstudio', model || 'default', credentialFingerprint(apiKey)].join(':');
-}
-
-export async function prepareWebAgent(agent, options = {}) {
-  await agent.ready();
-  if (Array.isArray(options.history) && options.history.length > 0) {
-    const agentMsgCount = agent.session?.messages?.length || 0;
-    const frontendMsgCount = options.history.length;
-    await agent.hydrateConversationHistory(options.history, {
-      sessionId: options.sessionId,
-      maxMessages: 24,
-      force: frontendMsgCount > agentMsgCount,
-    });
-  }
-  return agent;
-}
-
-export function cacheWebAgentConnection(cacheKey, connection) {
-  if (!cacheKey) return;
-  webAgentCache.delete(cacheKey);
-  webAgentCache.set(cacheKey, connection);
-  while (webAgentCache.size > MAX_WEB_AGENT_SESSIONS) {
-    const oldestKey = webAgentCache.keys().next().value;
-    const oldest = webAgentCache.get(oldestKey);
-    oldest?.agent?.saveSession?.().catch(() => {});
-    const msgCount = oldest?.agent?.session?.messages?.length || 0;
-    if (msgCount === 0) {
-      const storageFile = oldest?.agent?.session?.storageFile;
-      if (storageFile) {
-        fs.promises.unlink(storageFile).catch(() => {});
-      }
-    }
-    webAgentCache.delete(oldestKey);
-  }
-}
-
-export async function waitForLMStudio(baseUrl, timeoutMs = 8000) {
-  const client = new LLMClient({ provider: 'lmstudio', baseUrl });
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    try {
-      const health = await client.checkConnection();
-      if (health.connected) return health;
-    } catch {}
-    await new Promise(r => setTimeout(r, 600));
-  }
-  return null;
-}
-
-export async function attemptAutoStartLMStudio(baseUrl, model) {
-  const isWin = process.platform === 'win32';
-  const isMac = process.platform === 'darwin';
-
-  const candidates = isWin
-    ? [
-      `${process.env.LOCALAPPDATA}\\LM Studio\\LM Studio.exe`,
-      `${process.env.LOCALAPPDATA}\\Programs\\LM Studio\\LM Studio.exe`,
-      'C:\\Program Files\\LM Studio\\LM Studio.exe'
-    ]
-    : isMac
-      ? ['/Applications/LM Studio.app/Contents/MacOS/LM Studio']
-      : ['lmstudio', '/usr/local/bin/lmstudio', '/opt/lmstudio/bin/lmstudio'];
-
-  const exe = candidates.find(p => {
-    if (p.includes('/') || p.includes('\\')) {
-      try { return fs.existsSync(p); } catch { return false; }
-    }
-    return true;
-  });
-
-  if (!exe) return null;
-
-  try {
-    let port = '1234';
-    try { const parsedUrl = new URL(baseUrl); if (parsedUrl.port) port = parsedUrl.port; } catch {}
-
-    const safeModel = (typeof model === 'string' && /^[a-zA-Z0-9_\-\.\/]+$/.test(model) && !model.startsWith('-'))
-      ? model
-      : 'google/gemma-4-e4b';
-    const safePort = (/^\d{1,5}$/.test(port) && Number(port) > 0 && Number(port) <= 65535) ? port : '1234';
-
-    const child = spawn(exe, isWin
-      ? ['--model', safeModel, '--serve', '--port', safePort]
-      : ['serve', '--model', safeModel, '--port', safePort],
-      { detached: true, stdio: 'ignore', windowsHide: true }
-    );
-    child.unref();
-
-    return await waitForLMStudio(baseUrl, 10000);
-  } catch {
-    return null;
-  }
-}
-
-export async function resolveAgentConnection(customOptions = {}) {
-  const isAuto = !customOptions.provider || customOptions.provider === 'auto';
-  const serverProvider = currentAgent?.client?.provider || config.activeProvider || 'lmstudio';
-  const provider = isAuto ? serverProvider : customOptions.provider;
-
-  const serverModel = currentAgent?.client?.model || config.providers?.[provider]?.model || 'google/gemma-4-e4b';
-  const requestedModel = (customOptions.model && !isAuto)
-    ? customOptions.model
-    : (provider === serverProvider ? serverModel : (config.providers?.[provider]?.model || 'google/gemma-4-e4b'));
-
-  const isServerAgentMatch = Boolean(currentAgent?.client && provider === currentAgent.client.provider);
-  const baseUrl = (typeof customOptions.baseUrl === 'string' && customOptions.baseUrl.trim()
-    ? customOptions.baseUrl.trim().replace(/\/+$/, '')
-    : null)
-    || (isServerAgentMatch ? currentAgent.client.baseUrl : null)
-    || getProviderBaseUrl(provider);
-
-  const sessionId = normalizeWebSessionId(customOptions.sessionId);
- 
-  const apiKey = customOptions.apiKey
-    || (isServerAgentMatch ? currentAgent.client.apiKey : '')
-    || '';
-
-  const client = new LLMClient({
-    provider,
-    baseUrl,
-    model: requestedModel,
-    apiKey
-  });
-
-  const modelManager = new ModelManager(client, { requestedModel });
-  let resolution = await modelManager.resolve({ requestedModel });
-
-  if (provider === 'lmstudio' && resolution.state === 'server_offline' && process.env.NODE_ENV !== 'test' && !process.execArgv.includes('--test')) {
-    const started = await attemptAutoStartLMStudio(baseUrl, requestedModel);
-    if (started) {
-      resolution = await modelManager.resolve({ requestedModel });
-    }
-  }
-
-  if (provider === 'vllm' && resolution.state === 'server_offline' && !resolution.error?.includes('WSL')) {
-    const wslHint = 'vLLM runs on WSL/Linux port 8000 (Windows cannot host it natively). Start it with: wsl -d Ubuntu -- vllm serve <model> --port 8000';
-    resolution.error = resolution.error ? `${resolution.error}\n  Notice: ${wslHint}` : wslHint;
-  }
-
-  if (resolution.connected && resolution.selectedModel) {
-    const agent = new KikuAgent({
-      client,
-      thinkingMode: customOptions.thinking || 'show',
-      memory: new AgentMemory({ persistence: false }),
-      sessionId,
-      sessionPersistence: false,
-      allowedToolNames: PUBLIC_REMOTE_TOOL_NAMES,
-    });
-    await prepareWebAgent(agent, { history: customOptions.history, sessionId });
-    const connection = {
-      ready: true,
-      agent,
-      client,
-      provider,
-      model: resolution.selectedModel,
-      models: resolution.models || [],
-      usedFallback: resolution.usedFallback || false,
-      resolution,
-      contentHash: computeSessionHash(agent.session?.messages || [])
-    };
-    return connection;
-  }
-
-  return {
-    ready: false,
-    client,
-    provider,
-    model: requestedModel,
-    models: resolution.models || [],
-    state: resolution.state,
-    error: resolution.error || 'Server offline',
-    resolution
-  };
-}
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+import { LLMClient } from '../../agent/llmClient.js';
+import { KikuAgent } from '../../agent/agentCore.js';
+import { AgentMemory } from '../../agent/memory.js';
+import { ModelManager } from '../../agent/modelManager.js';
+import { config, getProviderBaseUrl, getPersistedActiveProvider } from '../../agent/config.js';
+import { validateInferenceBaseUrl } from './urlGuard.js';
+import { PUBLIC_REMOTE_TOOL_NAMES } from '../../agent/publicTools.js';
+import { registerBackgroundProcess } from '../../agent/processManager.js';
+import { wakeUpLmStudio } from '../../agent/lmStudioWakeup.js';
+
+export let sharedWebMemory = new AgentMemory({ persistence: false });
+export let currentAgent = null;
+
+export function setSharedWebMemory(mem) {
+  if (mem) sharedWebMemory = mem;
+}
+
+export function setCurrentAgent(agent) {
+  if (agent) {
+    currentAgent = agent;
+    if (agent.memory) sharedWebMemory = agent.memory;
+  }
+}
+
+export function normalizeWebSessionId(value) {
+  const normalized = String(value || '').trim().replace(/[^a-zA-Z0-9_-]+/g, '_').slice(0, 100);
+  return normalized || null;
+}
+
+export function credentialFingerprint(value) {
+  if (!value) return 'no-key';
+  return createHash('sha256').update(String(value)).digest('hex').slice(0, 12);
+}
+
+export function computeSessionHash(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return '';
+  const payload = messages.map(m => (m.role || '') + ':' + (m.parts?.[0]?.content || m.text || '')).join('|');
+  return createHash('sha256').update(payload).digest('hex').slice(0, 16);
+}
+
+
+export async function prepareWebAgent(agent, options = {}) {
+  await agent.ready();
+  if (Array.isArray(options.history) && options.history.length > 0) {
+    const agentMsgCount = agent.session?.messages?.length || 0;
+    const frontendMsgCount = options.history.length;
+    await agent.hydrateConversationHistory(options.history, {
+      sessionId: options.sessionId,
+      maxMessages: 24,
+      force: frontendMsgCount > agentMsgCount,
+    });
+  }
+  return agent;
+}
+
+
+export async function waitForLMStudio(baseUrl, timeoutMs = 8000) {
+  const client = new LLMClient({ provider: 'lmstudio', baseUrl });
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const health = await client.checkConnection();
+      if (health.connected) return health;
+    } catch {}
+    await new Promise(r => setTimeout(r, 600));
+  }
+  return null;
+}
+
+let lmStudioAutoStartPromise = null;
+export function attemptAutoStartLMStudio(baseUrl, model) {
+  if (lmStudioAutoStartPromise) return lmStudioAutoStartPromise;
+  lmStudioAutoStartPromise = attemptAutoStartLMStudioInner(baseUrl, model).finally(() => {
+    lmStudioAutoStartPromise = null;
+  });
+  return lmStudioAutoStartPromise;
+}
+
+async function attemptAutoStartLMStudioInner(baseUrl, model) {
+  try {
+    const res = await wakeUpLmStudio({
+      baseUrl,
+      model,
+      quiet: true,
+      maxWaitMs: 25000,
+    });
+    if (res.ok) {
+      return await waitForLMStudio(baseUrl, 5000);
+    }
+  } catch {}
+  return null;
+}
+
+export async function resolveAgentConnection(customOptions = {}) {
+  const isAuto = !customOptions.provider || customOptions.provider === 'auto';
+  const serverProvider = currentAgent?.client?.provider || config.activeProvider || 'lmstudio';
+  const provider = isAuto ? serverProvider : customOptions.provider;
+
+  const serverModel = currentAgent?.client?.model || config.providers?.[provider]?.model || 'google/gemma-4-e4b';
+  const requestedModel = (customOptions.model && !isAuto)
+    ? customOptions.model
+    : (provider === serverProvider ? serverModel : (config.providers?.[provider]?.model || 'google/gemma-4-e4b'));
+
+  const isServerAgentMatch = Boolean(currentAgent?.client && provider === currentAgent.client.provider);
+  const baseUrl = (typeof customOptions.baseUrl === 'string' && customOptions.baseUrl.trim()
+    ? customOptions.baseUrl.trim().replace(/\/+$/, '')
+    : null)
+    || (isServerAgentMatch ? currentAgent.client.baseUrl : null)
+    || getProviderBaseUrl(provider);
+
+  if (customOptions.callerIsTrusted !== undefined) {
+    const guard = await validateInferenceBaseUrl(baseUrl, { callerIsTrusted: customOptions.callerIsTrusted });
+    if (!guard.ok) { const error = new Error(guard.reason); error.statusCode = 400; throw error; }
+  }
+  const sessionId = normalizeWebSessionId(customOptions.sessionId);
+ 
+  const apiKey = customOptions.apiKey
+    || (isServerAgentMatch ? currentAgent.client.apiKey : '')
+    || '';
+
+  const client = new LLMClient({
+    provider,
+    baseUrl,
+    model: requestedModel,
+    apiKey
+  });
+
+  const modelManager = new ModelManager(client, { requestedModel });
+  let resolution = await modelManager.resolve({ requestedModel });
+
+  if (customOptions.allowAutoStart !== false && provider === 'lmstudio' && resolution.state === 'server_offline' && process.env.NODE_ENV !== 'test' && !process.execArgv.includes('--test')) {
+    const started = await attemptAutoStartLMStudio(baseUrl, requestedModel);
+    if (started) {
+      resolution = await modelManager.resolve({ requestedModel });
+    }
+  }
+
+  if (provider === 'vllm' && resolution.state === 'server_offline' && !resolution.error?.includes('WSL')) {
+    const wslHint = 'vLLM runs on WSL/Linux port 8000 (Windows cannot host it natively). Start it with: wsl -d Ubuntu -- vllm serve <model> --port 8000';
+    resolution.error = resolution.error ? `${resolution.error}\n  Notice: ${wslHint}` : wslHint;
+  }
+
+  if (resolution.connected && resolution.selectedModel) {
+    const agent = new KikuAgent({
+      client,
+      thinkingMode: customOptions.thinking || 'show',
+      memory: new AgentMemory({ persistence: false }),
+      sessionId,
+      sessionPersistence: false,
+      allowedToolNames: PUBLIC_REMOTE_TOOL_NAMES,
+    });
+    await prepareWebAgent(agent, { history: customOptions.history, sessionId });
+    const connection = {
+      ready: true,
+      agent,
+      client,
+      provider,
+      model: resolution.selectedModel,
+      models: resolution.models || [],
+      usedFallback: resolution.usedFallback || false,
+      resolution,
+      contentHash: computeSessionHash(agent.session?.messages || [])
+    };
+    return connection;
+  }
+
+  return {
+    ready: false,
+    client,
+    provider,
+    model: requestedModel,
+    models: resolution.models || [],
+    state: resolution.state,
+    error: resolution.error || 'Server offline',
+    resolution
+  };
+}

package/server/web-chat/core/conversationContext.js

@@ -38,10 +38,17 @@ function cleanHistoryText(value) {
 
 export function detectConversationDomain(value) {
   const text = String(value || '');
+  let bestDomain = 'general';
+  let maxScore = 0;
   for (const [domain, pattern] of Object.entries(DOMAIN_PATTERNS)) {
-    if (pattern.test(text)) return domain;
+    const matches = text.match(new RegExp(pattern.source, 'gi'));
+    const score = matches ? matches.length : 0;
+    if (score > maxScore) {
+      maxScore = score;
+      bestDomain = domain;
+    }
   }
-  return 'general';
+  return bestDomain;
 }
 
 export function isContextDependentQuery(query) {