neoagent 2.4.2-beta.4 → 2.4.2-beta.6

package/server/services/ai/toolSelector.js

@@ -3,26 +3,40 @@
 /**
  * Tool selection strategy:
  *
- * Built-ins: always passed in full — descriptions are capped short by
- * compactToolDefinition({ includeDescriptions: true }) in tools.js, so the
- * overhead is a fixed ~100 tokens/tool and the model always knows every tool
- * that exists.
- *
- * MCP tools: user-defined and potentially numerous. Include all when the set
- * is small; keyword-filter when the registry grows large.
+ * Every tool stays visible in the catalog. Only full JSON schemas are limited
+ * per model turn because several providers enforce schema-count limits.
  */
 
-const MCP_ALWAYS_INCLUDE_THRESHOLD = 20;
-const MAX_TOOLS = 128; // Strict provider limit (e.g. Github Copilot / OpenAI)
+const MAX_TOOLS = 20;
 const ALWAYS_INCLUDE_BUILT_INS = [
+  'task_complete',
+  'activate_tools',
+  'think',
   'send_message',
-  'create_task',
-  'list_tasks',
-  'delete_task',
-  'update_task',
+  'send_interim_update',
 ];
 
+function compactDescription(value, maxChars = 180) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars - 3).trimEnd()}...`;
+}
+
+function buildToolCatalog(tools = []) {
+  return tools
+    .filter((tool) => String(tool?.name || '').trim())
+    .map((tool) => ({
+      name: String(tool.name).trim(),
+      description: compactDescription(tool.description),
+      source: tool.serverId ? `mcp:${tool.serverId}` : 'built-in',
+    }))
+    .sort((left, right) => left.name.localeCompare(right.name))
+    .map((tool) => `${tool.name} | ${tool.source} | ${tool.description || 'No description supplied.'}`)
+    .join('\n');
+}
+
 function ensureRequiredTools(selectedTools = [], builtInTools = [], options = {}) {
+  const limit = Number(options.maxTools) || MAX_TOOLS;
   const requiredNames = [...ALWAYS_INCLUDE_BUILT_INS];
   if (options.widgetId) requiredNames.push('save_widget_snapshot');
   if (!requiredNames.length) return selectedTools;
@@ -34,7 +48,7 @@ function ensureRequiredTools(selectedTools = [], builtInTools = [], options = {}
     const required = builtInTools.find((tool) => tool?.name === toolName);
     if (!required) continue;
 
-    if (selected.length < MAX_TOOLS) {
+    if (selected.length < limit) {
       selected.push(required);
       continue;
     }
@@ -57,43 +71,75 @@ function ensureRequiredTools(selectedTools = [], builtInTools = [], options = {}
   return selected;
 }
 
-function selectMcpTools(task, mcpTools = []) {
-  if (!mcpTools.length) return [];
-  if (mcpTools.length <= MCP_ALWAYS_INCLUDE_THRESHOLD) return mcpTools;
+function selectInitialTools(allTools = [], suggestedNames = [], options = {}) {
+  const requested = new Set(
+    (Array.isArray(suggestedNames) ? suggestedNames : [])
+      .map((name) => String(name || '').trim())
+      .filter(Boolean),
+  );
+  const selected = allTools.filter((tool) => requested.has(tool?.name));
+  return ensureRequiredTools(selected.slice(0, MAX_TOOLS), allTools, options).slice(0, MAX_TOOLS);
+}
 
-  // Large MCP registry: match by tool name, original name, or server id so we
-  // still surface the right tools without dumping hundreds of schemas.
-  const normalized = String(task || '').toLowerCase();
-  const explicitMcp = /\bmcp\b|\bmodel context protocol\b/.test(normalized);
+function activateTools(currentTools = [], allTools = [], requestedNames = [], options = {}) {
+  const knownByName = new Map(allTools.map((tool) => [tool?.name, tool]));
+  let next = ensureRequiredTools(currentTools, allTools, options);
+  const activated = [];
+  const evicted = [];
+  const unknown = [];
+  const notActivated = [];
+  const requested = [...new Set(
+    (Array.isArray(requestedNames) ? requestedNames : [])
+      .map((rawName) => String(rawName || '').trim())
+      .filter(Boolean),
+  )];
+  for (const name of requested) {
+    const tool = knownByName.get(name);
+    if (!tool) {
+      unknown.push(name);
+      continue;
+    }
+    if (next.some((item) => item?.name === name)) continue;
+    if (next.length >= MAX_TOOLS) {
+      const replaceIndex = next.findIndex((item) => (
+        !ALWAYS_INCLUDE_BUILT_INS.includes(item?.name)
+        && !requested.includes(item?.name)
+      ));
+      if (replaceIndex === -1) {
+        notActivated.push(name);
+        continue;
+      }
+      evicted.push(next[replaceIndex].name);
+      next.splice(replaceIndex, 1);
+    }
+    next.push(tool);
+    activated.push(name);
+  }
+  next = ensureRequiredTools(next, allTools, options).slice(0, MAX_TOOLS);
+  return {
+    tools: next,
+    activated,
+    evicted,
+    unknown,
+    notActivated,
+  };
+}
 
-  return mcpTools.filter((tool) => {
-    if (explicitMcp) return true;
-    const name = String(tool.name || '').toLowerCase();
-    const original = String(tool.originalName || '').toLowerCase();
-    const server = String(tool.serverId || '').toLowerCase();
-    return normalized.includes(name) || normalized.includes(original) || (server && normalized.includes(server));
-  });
+function selectMcpTools(_task, mcpTools = []) {
+  return Array.isArray(mcpTools) ? mcpTools : [];
 }
 
 function selectToolsForTask(task, builtInTools = [], mcpTools = [], _options = {}) {
   const selectedMcp = selectMcpTools(task, mcpTools);
-  const options = _options || {};
-  let selected;
-  
-  if (builtInTools.length + selectedMcp.length <= MAX_TOOLS) {
-    selected = [...builtInTools, ...selectedMcp];
-    return ensureRequiredTools(selected, builtInTools, options);
-  }
-
-  // If we exceed the limit, prioritize base tools and take as many MCP tools as fit
-  const remainingSpace = MAX_TOOLS - builtInTools.length;
-  if (remainingSpace > 0) {
-    selected = [...builtInTools, ...selectedMcp.slice(0, remainingSpace)];
-    return ensureRequiredTools(selected, builtInTools, options);
-  }
-  
-  selected = builtInTools.slice(0, MAX_TOOLS);
-  return ensureRequiredTools(selected, builtInTools, options);
+  void _options;
+  return [...builtInTools, ...selectedMcp];
 }
 
-module.exports = { selectToolsForTask, selectMcpTools };
+module.exports = {
+  MAX_TOOLS,
+  activateTools,
+  buildToolCatalog,
+  selectInitialTools,
+  selectToolsForTask,
+  selectMcpTools,
+};

package/server/services/ai/tools.js

@@ -73,7 +73,7 @@ function compactToolDefinition(tool, options = {}) {
     };
 
     if (options.includeDescriptions) {
-        compact.description = compactText(tool.description, 120);
+        compact.description = compactText(tool.description, 320);
     }
 
     if (tool.parameters?.properties) {
@@ -81,7 +81,7 @@ function compactToolDefinition(tool, options = {}) {
         for (const [key, value] of Object.entries(tool.parameters.properties)) {
             properties[key] = { ...value };
             if (options.includeDescriptions && value.description) {
-                properties[key].description = compactText(value.description, 70);
+                properties[key].description = compactText(value.description, 160);
             } else {
                 delete properties[key].description;
             }
@@ -786,9 +786,10 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     key: { type: 'string', enum: ['user_profile', 'preferences', 'ai_personality'], description: 'user_profile: who the user is, preferences: standing likes/dislikes, ai_personality: concise durable notes for how the agent should behave for this user' },
-                    value: { type: 'string', description: 'Value to set. Keep it concise — this is injected into every single prompt.' }
+                    value: { type: 'string', description: 'Value to set. Keep it concise — this is injected into every single prompt.' },
+                    confirmed: { type: 'boolean', description: 'Must be true only when the user explicitly requested this core-memory change in the current conversation.' }
                 },
-                required: ['key', 'value']
+                required: ['key', 'value', 'confirmed']
             }
         },
         {
@@ -919,6 +920,37 @@ function getAvailableTools(app, options = {}) {
                 required: ['path', 'query']
             }
         },
+        {
+            name: 'code_navigate',
+            description: 'Navigate source code with ranked lexical matches, AST-derived JavaScript/TypeScript symbols, or workspace-scoped semantic retrieval. Returns excerpts and line references instead of complete files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    mode: { type: 'string', enum: ['lexical', 'structure', 'semantic'], description: 'Search mode.' },
+                    path: { type: 'string', description: 'Workspace file or directory.' },
+                    query: { type: 'string', description: 'Required for lexical and semantic modes.' },
+                    include: { type: 'string', description: 'Optional ripgrep glob for lexical mode.' },
+                    limit: { type: 'number', description: 'Maximum semantic results.' }
+                },
+                required: ['mode', 'path']
+            }
+        },
+        {
+            name: 'query_structured_data',
+            description: 'Read workspace CSV, TSV, JSON, or SQLite data using format-aware parsers. SQLite statements must be read-only and parameters are bound separately.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Workspace data file.' },
+                    sql: { type: 'string', description: 'Read-only SQLite query.' },
+                    parameters: { type: 'object', description: 'Named SQLite query parameters.' },
+                    columns: { type: 'array', items: { type: 'string' }, description: 'Columns to return for CSV, TSV, or JSON.' },
+                    equals: { type: 'object', description: 'Exact field filters for CSV, TSV, or JSON.' },
+                    limit: { type: 'number', description: 'Maximum rows, capped at 1000.' }
+                },
+                required: ['path']
+            }
+        },
         {
             name: 'http_request',
             description: 'Make an HTTP request to any URL',
@@ -989,6 +1021,21 @@ function getAvailableTools(app, options = {}) {
                 required: ['thought']
             }
         },
+        {
+            name: 'activate_tools',
+            description: 'Activate tools by exact catalog name for later model turns. When the schema limit is full, unrelated active schemas are replaced; every catalog tool remains available for later activation.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    names: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Exact tool names from the available tool catalog.'
+                    }
+                },
+                required: ['names']
+            }
+        },
         {
             name: 'spawn_subagent',
             description: 'Spawn an independent sub-agent asynchronously. Returns a handle immediately so the parent run can continue, list helpers, wait later, or cancel if plans change.',
@@ -997,7 +1044,9 @@ function getAvailableTools(app, options = {}) {
                 properties: {
                     task: { type: 'string', description: 'The task for the sub-agent to complete' },
                     model: { type: 'string', description: 'Model override for the sub-agent (e.g. gpt-4o-mini for cheap tasks)' },
-                    context: { type: 'string', description: 'Additional context to pass to the sub-agent' }
+                    context: { type: 'string', description: 'Only the constraints and evidence the sub-agent needs.' },
+                    required_artifacts: { type: 'array', items: { type: 'string' }, description: 'Artifacts the sub-agent must return.' },
+                    tools: { type: 'array', items: { type: 'string' }, description: 'Exact active tool names the sub-agent may need.' }
                 },
                 required: ['task']
             }
@@ -1879,7 +1928,10 @@ async function executeTool(toolName, args, context, engine) {
         case 'memory_update_core': {
             const { MemoryManager } = require('../memory/manager');
             const mm = new MemoryManager();
-            mm.updateCore(userId, args.key, args.value, { agentId });
+            if (args.confirmed !== true) {
+                return { error: 'Core memory updates require explicit current-session user confirmation.' };
+            }
+            mm.updateCore(userId, args.key, args.value, { agentId, confirmed: true });
             return { success: true, key: args.key, message: 'Core memory updated' };
         }
 
@@ -2258,6 +2310,26 @@ async function executeTool(toolName, args, context, engine) {
             }
         }
 
+        case 'code_navigate': {
+            const service = app?.locals?.codeNavigationService;
+            if (!service) return { error: 'Code navigation service is unavailable.' };
+            try {
+                return await service.navigate(userId, args);
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
+        case 'query_structured_data': {
+            const service = app?.locals?.structuredDataService;
+            if (!service) return { error: 'Structured data service is unavailable.' };
+            try {
+                return service.query(userId, args);
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
         case 'http_request': {
             const controller = new AbortController();
             const timeoutMs = args.timeout_ms || 30000;
@@ -2776,11 +2848,12 @@ async function executeTool(toolName, args, context, engine) {
 
         case 'spawn_subagent': {
             try {
-                const task = args.context ? `${args.task}\n\nContext: ${args.context}` : args.task;
-                return await engine.spawnSubagent(userId, runId, task, {
+                return await engine.spawnSubagent(userId, runId, args.task, {
                     app,
                     model: args.model || null,
                     context: args.context || null,
+                    requiredArtifacts: args.required_artifacts || [],
+                    selectedTools: args.tools || engine.getActiveTools(runId).map((tool) => tool.name),
                     agentId,
                 });
             } catch (err) {
@@ -2788,6 +2861,13 @@ async function executeTool(toolName, args, context, engine) {
             }
         }
 
+        case 'activate_tools':
+            try {
+                return engine.activateToolsForRun(runId, args.names || []);
+            } catch (err) {
+                return { error: `activate_tools failed: ${err.message}` };
+            }
+
         case 'delegate_to_agent': {
             try {
                 if (triggerSource === 'agent_delegation') {
@@ -2862,7 +2942,7 @@ async function executeTool(toolName, args, context, engine) {
 
             const skillRunner = sk();
             if (skillRunner) {
-                const skillResult = await skillRunner.executeTool(toolName, args, { userId });
+                const skillResult = await skillRunner.executeTool(toolName, args, { userId, agentId, runId });
                 if (skillResult !== null) return skillResult;
             }
 

package/server/services/ai/usage.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const db = require('../../db/database');
+
+function finiteToken(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
+}
+
+function normalizeUsage(usage = {}) {
+  if (!usage || typeof usage !== 'object') return null;
+  const inputTokens = finiteToken(
+    usage.inputTokens
+    ?? usage.promptTokens
+    ?? usage.input_tokens
+    ?? usage.prompt_tokens,
+  );
+  const outputTokens = finiteToken(
+    usage.outputTokens
+    ?? usage.completionTokens
+    ?? usage.output_tokens
+    ?? usage.completion_tokens,
+  );
+  const reasoningTokens = finiteToken(
+    usage.reasoningTokens
+    ?? usage.reasoning_tokens
+    ?? usage.output_tokens_details?.reasoning_tokens
+    ?? usage.completion_tokens_details?.reasoning_tokens,
+  );
+  const cachedReadTokens = finiteToken(
+    usage.cachedReadTokens
+    ?? usage.cached_read_tokens
+    ?? usage.cache_read_input_tokens
+    ?? usage.prompt_tokens_details?.cached_tokens
+    ?? usage.input_tokens_details?.cached_tokens
+    ?? usage.cachedContentTokenCount,
+  );
+  const cacheWriteTokens = finiteToken(
+    usage.cacheWriteTokens
+    ?? usage.cache_write_tokens
+    ?? usage.cache_creation_input_tokens,
+  );
+  const explicitTotal = finiteToken(usage.totalTokens ?? usage.total_tokens);
+  const totalTokens = explicitTotal || inputTokens + outputTokens;
+  return {
+    inputTokens,
+    outputTokens,
+    reasoningTokens,
+    cachedReadTokens,
+    cacheWriteTokens,
+    totalTokens,
+  };
+}
+
+function mergeUsage(left, right) {
+  const a = normalizeUsage(left) || normalizeUsage({});
+  const b = normalizeUsage(right) || normalizeUsage({});
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    reasoningTokens: a.reasoningTokens + b.reasoningTokens,
+    cachedReadTokens: a.cachedReadTokens + b.cachedReadTokens,
+    cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens,
+    totalTokens: a.totalTokens + b.totalTokens,
+  };
+}
+
+function recordModelUsage({
+  runId,
+  stepId = null,
+  userId,
+  agentId = null,
+  provider,
+  model,
+  phase = 'model_turn',
+  usage,
+  latencyMs = 0,
+  estimatedCostUsd = null,
+  metadata = {},
+}) {
+  const normalized = normalizeUsage(usage);
+  if (!runId || !userId || !provider || !model || !normalized) return null;
+  const result = db.prepare(
+    `INSERT INTO agent_model_usage (
+      run_id, step_id, user_id, agent_id, provider, model, phase,
+      input_tokens, output_tokens, reasoning_tokens, cached_read_tokens,
+      cache_write_tokens, total_tokens, estimated_cost_usd, latency_ms, metadata_json
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    runId,
+    stepId,
+    userId,
+    agentId,
+    String(provider),
+    String(model),
+    String(phase),
+    normalized.inputTokens,
+    normalized.outputTokens,
+    normalized.reasoningTokens,
+    normalized.cachedReadTokens,
+    normalized.cacheWriteTokens,
+    normalized.totalTokens,
+    Number.isFinite(Number(estimatedCostUsd)) ? Number(estimatedCostUsd) : null,
+    Math.max(0, Math.floor(Number(latencyMs) || 0)),
+    JSON.stringify(metadata && typeof metadata === 'object' ? metadata : {}),
+  );
+  return Number(result.lastInsertRowid);
+}
+
+module.exports = {
+  mergeUsage,
+  normalizeUsage,
+  recordModelUsage,
+};

package/server/services/manager.js

@@ -21,6 +21,11 @@ const { MemoryIngestionService } = require('./memory/ingestion');
 const { ArtifactStore } = require('./artifacts/store');
 const { RuntimeManager } = require('./runtime/manager');
 const { WorkspaceManager } = require('./workspace/manager');
+const { CodeNavigationService } = require('./workspace/code_navigation');
+const { StructuredDataService } = require('./workspace/structured_data');
+const { TaskWebhookService } = require('./tasks/webhooks');
+const { LearningManager } = require('./ai/learning');
+const { CapabilityAuditService } = require('./security/capability_audit');
 const { BrowserExtensionRegistry } = require('./browser/extension/registry');
 const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
@@ -52,6 +57,8 @@ function createArtifactStore(app) {
 
 function createWorkspaceManager(app) {
   const workspaceManager = registerLocal(app, 'workspaceManager', new WorkspaceManager());
+  registerLocal(app, 'codeNavigationService', new CodeNavigationService({ workspaceManager }));
+  registerLocal(app, 'structuredDataService', new StructuredDataService({ workspaceManager }));
   logServiceReady('Workspace manager ready');
   return workspaceManager;
 }
@@ -88,6 +95,22 @@ function createDesktopCompanionRegistry(app) {
 
 function createMemoryManager(app) {
   const memoryManager = registerLocal(app, 'memoryManager', new MemoryManager());
+  const reconcile = () => {
+    const users = db.prepare('SELECT id FROM users').all();
+    for (const user of users) {
+      const agents = db.prepare("SELECT id FROM agents WHERE user_id = ? AND status = 'active'").all(user.id);
+      for (const agent of agents) {
+        try {
+          memoryManager.reconcileFacts(user.id, { agentId: agent.id });
+        } catch (err) {
+          console.warn('[Memory] Fact reconciliation failed:', err.message);
+        }
+      }
+    }
+  };
+  const timer = setInterval(reconcile, 6 * 60 * 60 * 1000);
+  timer.unref?.();
+  registerLocal(app, 'memoryReconciliationTimer', timer);
   logServiceReady('Memory manager ready');
   return memoryManager;
 }
@@ -473,6 +496,12 @@ async function startServices(app, io) {
       skillRunner,
       workspaceManager: app.locals.workspaceManager,
     });
+    registerLocal(app, 'learningManager', new LearningManager(skillRunner, io));
+    registerLocal(app, 'capabilityAuditService', new CapabilityAuditService({
+      mcpClient,
+      skillRunner,
+    }));
+    agentEngine.learningManager = app.locals.learningManager;
 
     createMultiStep(app, agentEngine, io);
     createCommandRouter(app);
@@ -499,6 +528,7 @@ async function startServices(app, io) {
     });
 
     const taskRuntime = startTaskRuntime(app, io, agentEngine);
+    registerLocal(app, 'taskWebhookService', new TaskWebhookService({ taskRuntime }));
 
     configureRealtime(app, io, {
       agentEngine,
@@ -525,6 +555,10 @@ async function startServices(app, io) {
 async function stopServices(app) {
   const tasks = [];
   console.log('[Services] Stopping services');
+  if (app.locals.memoryReconciliationTimer) {
+    clearInterval(app.locals.memoryReconciliationTimer);
+    app.locals.memoryReconciliationTimer = null;
+  }
 
   if (app.locals.taskRuntime) {
     tasks.push(