kiku-agent 1.0.0 → 1.0.3

package/server/agent/modelManager.js

@@ -0,0 +1,77 @@
+const NON_CHAT_MODEL = /(embed|embedding|rerank|whisper|tts|clip)/i;
+
+export class ModelManager {
+  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.lastResolution = null;
+  }
+
+  async inspect() {
+    const health = await this.client.checkConnection();
+    const models = health.models || [];
+    return {
+      ...health,
+      models,
+      selectedModel: this.client.model,
+      state: !health.connected
+        ? 'server_offline'
+        : models.length === 0
+          ? 'server_online_no_models'
+          : models.includes(this.client.model)
+            ? 'ready'
+            : 'requested_model_missing',
+    };
+  }
+
+  select(model, availableModels = []) {
+    const requested = 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}`);
+    }
+    if (NON_CHAT_MODEL.test(requested)) {
+      throw new Error(`Model does not appear to support chat: ${requested}`);
+    }
+    this.client.model = requested;
+    this.requestedModel = requested;
+    return requested;
+  }
+
+  async resolve(options = {}) {
+    const health = await this.client.checkConnection();
+    if (!health.connected) {
+      return this._record({ state: 'server_offline', connected: false, models: [], error: health.error });
+    }
+    const models = health.models || [];
+    if (models.length === 0) {
+      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 gemma = models.find(id => /gemma/i.test(id) && !NON_CHAT_MODEL.test(id));
+    const chatFallback = models.find(id => !NON_CHAT_MODEL.test(id));
+    const selected = exact || configuredFallback || 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',
+      connected: true,
+      models,
+      selectedModel: selected,
+      requestedModel: requested,
+      usedFallback: !exact,
+    });
+  }
+
+  _record(result) {
+    this.lastResolution = { ...result, checkedAt: new Date().toISOString() };
+    return this.lastResolution;
+  }
+}

package/server/agent/research.js

@@ -0,0 +1,202 @@
+import { ResearchSubagent } from './subagent.js';
+import { executeTool } from './tools.js';
+import { eventBus, Events } from './eventBus.js';
+
+const CATALOG_TOOLS = Object.freeze([
+  'global_search', 'get_profile_and_fandom', 'search_works', 'get_work_detail',
+  'get_character_roles', 'search_discography', 'get_music_videos',
+  'get_media_links', 'get_brand_endorsements', 'get_career_timeline',
+  'get_awards', 'get_social_feed',
+]);
+const WEB_TOOLS = Object.freeze(['web_search', 'web_extract', 'fetch_webpage']);
+const VERIFY_TOOLS = Object.freeze([...CATALOG_TOOLS, ...WEB_TOOLS]);
+
+function uniqueUrls(text) {
+  const matches = String(text || '').match(/https?:\/\/[^\s<>()\]]+/g) || [];
+  return [...new Set(matches.map(url => url.replace(/[.,;:!?]+$/, '')))];
+}
+
+function stableSignature(name, args) {
+  const sort = value => {
+    if (Array.isArray(value)) return value.map(sort);
+    if (value && typeof value === 'object') {
+      return Object.fromEntries(Object.keys(value).sort().map(key => [key, sort(value[key])]));
+    }
+    return value;
+  };
+  return `${name}:${JSON.stringify(sort(args || {}))}`;
+}
+
+function taskPlan(question, mode) {
+  const verifyInstruction = mode === 'verify'
+    ? 'Classify the claim as verified, unverified, conflicting, or false. Do not infer confirmation from silence.'
+    : 'Identify corroboration, contradictions, and missing evidence.';
+  return [
+    {
+      id: 'catalog',
+      label: 'Kiku catalog',
+      tools: CATALOG_TOOLS,
+      objective: `Search the verified local Kiku catalog for this question: ${question}`,
+    },
+    {
+      id: 'web',
+      label: 'Current web sources',
+      tools: WEB_TOOLS,
+      objective: `Find current primary or authoritative web sources for this Ju Jingyi question: ${question}`,
+    },
+    {
+      id: 'verify',
+      label: 'Independent verifier',
+      tools: VERIFY_TOOLS,
+      objective: `${verifyInstruction}\nQuestion or claim: ${question}`,
+    },
+  ];
+}
+
+export class ResearchOrchestrator {
+  constructor(options = {}) {
+    if (!options.client) throw new Error('ResearchOrchestrator requires an LLM client.');
+    this.client = options.client;
+    this.executeTool = options.executeTool;
+    this.maxWorkers = Math.min(Math.max(options.maxWorkers || 3, 1), 3);
+    this.maxIterations = Math.min(Math.max(options.maxIterations || 3, 1), 5);
+    this.active = null;
+    this.lastResult = null;
+  }
+
+  getStatus() {
+    if (!this.active) return { state: 'idle', lastResult: this.lastResult };
+    return {
+      state: 'running',
+      id: this.active.id,
+      question: this.active.question,
+      startedAt: this.active.startedAt,
+      workers: [...this.active.workers.values()],
+    };
+  }
+
+  cancel() {
+    if (!this.active) return false;
+    this.active.controller.abort();
+    return true;
+  }
+
+  async run(question, options = {}) {
+    const query = String(question || '').trim();
+    if (!query) throw new Error('A research question is required.');
+    if (this.active) throw new Error('A research job is already running.');
+
+    const controller = new AbortController();
+    const abortParent = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', abortParent, { once: true });
+    const plan = taskPlan(query, options.mode || 'research').slice(0, this.maxWorkers);
+    const job = {
+      id: `research_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      question: query,
+      startedAt: new Date().toISOString(),
+      controller,
+      workers: new Map(plan.map(task => [task.id, { id: task.id, label: task.label, state: 'pending', toolCalls: 0 }])),
+    };
+    const sharedToolCache = new Map();
+    const cachedExecute = async (name, args) => {
+      const signature = stableSignature(name, args);
+      if (!sharedToolCache.has(signature)) {
+        sharedToolCache.set(signature, Promise.resolve((this.executeTool || executeTool)(name, args)));
+      }
+      return sharedToolCache.get(signature);
+    };
+    this.active = job;
+    options.onProgress?.({ type: 'start', id: job.id, workers: plan.length });
+    eventBus.emit(Events.AGENT_PLAN_START, {
+      planId: job.id,
+      question: query,
+      steps: plan.map(p => ({ id: p.id, label: p.label, state: 'pending', objective: p.objective }))
+    });
+
+    try {
+      const settled = await Promise.allSettled(plan.map(async task => {
+        const status = job.workers.get(task.id);
+        status.state = 'running';
+        options.onProgress?.({ type: 'worker-start', id: task.id, label: task.label });
+        eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+          planId: job.id,
+          stepId: task.id,
+          state: 'running',
+          label: task.label,
+        });
+
+        const worker = new ResearchSubagent({
+          client: this.client,
+          executeTool: cachedExecute,
+          allowedTools: task.tools,
+          maxIterations: this.maxIterations,
+        });
+        const result = await worker.run(task.objective, {
+          signal: controller.signal,
+          skillContext: options.skillContext,
+          onProgress: event => {
+            if (event.type === 'tool') status.toolCalls += 1;
+            options.onProgress?.({ ...event, workerId: task.id, label: task.label });
+          },
+        });
+        status.state = 'complete';
+        options.onProgress?.({ type: 'worker-complete', id: task.id, label: task.label });
+        eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+          planId: job.id,
+          stepId: task.id,
+          state: 'complete',
+          label: task.label,
+        });
+        return { id: task.id, label: task.label, ...result };
+      }));
+
+      const reports = settled.map((entry, index) => {
+        if (entry.status === 'fulfilled') return entry.value;
+        const task = plan[index];
+        const status = job.workers.get(task.id);
+        status.state = controller.signal.aborted ? 'cancelled' : 'failed';
+        status.error = entry.reason?.message || 'Unknown worker error';
+        return { id: task.id, label: task.label, answer: '', error: status.error, toolCalls: [] };
+      });
+      if (controller.signal.aborted) throw controller.signal.reason || new DOMException('Aborted', 'AbortError');
+
+      const usable = reports.filter(report => report.answer);
+      if (usable.length === 0) throw new Error('All research workers failed.');
+      const synthesisPrompt = options.mode === 'verify'
+        ? 'Return a clear verdict: VERIFIED, UNVERIFIED, CONFLICTING, or FALSE. Explain briefly and cite only URLs present in the reports.'
+        : 'Synthesize a direct, polished answer. Separate verified facts, conflicts, and missing evidence. Cite only URLs present in the reports.';
+      const synthesis = await this.client.chat({
+        messages: [
+          { role: 'system', content: `You are the Kiku research editor. ${synthesisPrompt} Never invent a source, date, title, or URL. Match the language of the question. Do not reveal hidden reasoning.` },
+          { role: 'user', content: JSON.stringify({ question: query, reports: usable.map(({ label, answer }) => ({ label, answer })) }) },
+        ],
+        temperature: 0.1,
+        stream: false,
+        signal: controller.signal,
+      });
+      const answer = synthesis?.content || usable.map(report => `### ${report.label}\n${report.answer}`).join('\n\n');
+      const sources = uniqueUrls(usable.map(report => report.answer).join('\n'));
+      const result = {
+        id: job.id,
+        mode: options.mode || 'research',
+        question: query,
+        answer,
+        sources,
+        reports,
+        startedAt: job.startedAt,
+        completedAt: new Date().toISOString(),
+      };
+      this.lastResult = result;
+      options.onProgress?.({ type: 'complete', id: job.id, sources: sources.length });
+      eventBus.emit(Events.AGENT_PLAN_COMPLETE, {
+        planId: job.id,
+        sourcesCount: sources.length,
+        reportsCount: reports.length,
+      });
+      return result;
+    } finally {
+      options.signal?.removeEventListener('abort', abortParent);
+      this.active = null;
+    }
+  }
+}