neoagent 1.4.0 → 1.4.3

package/server/services/ai/toolResult.js

@@ -0,0 +1,151 @@
+function clampText(text, maxChars) {
+  const str = String(text || '');
+  if (str.length <= maxChars) return str;
+  return `${str.slice(0, maxChars)}\n...[truncated, ${str.length} chars total]`;
+}
+
+function lineExcerpt(text, maxLines = 12, maxChars = 700) {
+  const str = String(text || '').trim();
+  if (!str) return '';
+  return clampText(str.split('\n').slice(0, maxLines).join('\n'), maxChars);
+}
+
+function toJsonText(value, maxChars) {
+  const raw = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+  return clampText(raw, maxChars);
+}
+
+function trimObject(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined && value !== null && value !== ''));
+}
+
+function clampEnvelope(envelope, hardLimit) {
+  const raw = JSON.stringify(envelope);
+  if (raw.length <= hardLimit) return raw;
+
+  const trimmed = { ...envelope };
+  if (trimmed.summary) trimmed.summary = clampText(trimmed.summary, Math.max(200, hardLimit - 300));
+  if (trimmed.stdout) trimmed.stdout = clampText(trimmed.stdout, Math.max(160, hardLimit - 400));
+  if (trimmed.stderr) trimmed.stderr = clampText(trimmed.stderr, Math.max(120, hardLimit - 400));
+  if (trimmed.content) trimmed.content = clampText(trimmed.content, Math.max(160, hardLimit - 400));
+  if (trimmed.excerpt) trimmed.excerpt = clampText(trimmed.excerpt, Math.max(160, hardLimit - 400));
+  if (trimmed.result) trimmed.result = clampText(trimmed.result, Math.max(160, hardLimit - 400));
+
+  const fallback = JSON.stringify(trimmed);
+  if (fallback.length <= hardLimit) return fallback;
+  return clampText(fallback, hardLimit);
+}
+
+function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
+  const softLimit = Math.max(400, Math.min(Number(options.softLimit) || 1200, 2000));
+  const hardLimit = Math.max(softLimit, Math.min(Number(options.hardLimit) || 2000, 3000));
+
+  let envelope;
+
+  switch (toolName) {
+    case 'execute_command':
+      envelope = trimObject({
+        tool: toolName,
+        exitCode: toolResult?.exitCode,
+        cwd: toolResult?.cwd || toolArgs.cwd,
+        killed: toolResult?.killed || false,
+        stdout: lineExcerpt(toolResult?.stdout, 12, Math.floor(softLimit * 0.45)),
+        stderr: lineExcerpt(toolResult?.stderr, 8, Math.floor(softLimit * 0.25))
+      });
+      break;
+
+    case 'read_file':
+      envelope = trimObject({
+        tool: toolName,
+        path: toolArgs.path,
+        startLine: toolArgs.start_line,
+        endLine: toolArgs.end_line,
+        content: lineExcerpt(toolResult?.content || toolResult, 20, Math.floor(softLimit * 0.7))
+      });
+      break;
+
+    case 'search_files':
+      envelope = trimObject({
+        tool: toolName,
+        count: toolResult?.count || toolResult?.matches?.length || 0,
+        matches: (toolResult?.matches || []).slice(0, 6).map((match) => trimObject({
+          file: match.file,
+          line: match.line,
+          content: clampText(match.content, 160)
+        }))
+      });
+      break;
+
+    case 'browser_extract':
+      envelope = trimObject({
+        tool: toolName,
+        selector: toolArgs.selector || 'body',
+        attribute: toolArgs.attribute || 'innerText',
+        excerpt: lineExcerpt(toolResult?.result || toolResult?.content || toolResult, 18, Math.floor(softLimit * 0.7))
+      });
+      break;
+
+    case 'http_request':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.status,
+        headers: trimObject({
+          contentType: toolResult?.headers?.['content-type'] || toolResult?.headers?.['Content-Type'],
+          contentLength: toolResult?.headers?.['content-length'] || toolResult?.headers?.['Content-Length']
+        }),
+        excerpt: lineExcerpt(toolResult?.body || toolResult, 18, Math.floor(softLimit * 0.65))
+      });
+      break;
+
+    case 'send_message':
+    case 'make_call':
+    case 'memory_save':
+    case 'memory_recall':
+    case 'memory_update_core':
+    case 'memory_read':
+    case 'memory_write':
+    case 'create_scheduled_task':
+    case 'schedule_run':
+    case 'list_scheduled_tasks':
+    case 'delete_scheduled_task':
+    case 'update_scheduled_task':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.success === false || toolResult?.error ? 'error' : 'ok',
+        message: clampText(toolResult?.message || toolResult?.error || '', Math.floor(softLimit * 0.45)),
+        result: clampText(JSON.stringify(trimObject({
+          id: toolResult?.id,
+          key: toolResult?.key,
+          deleted: toolResult?.deleted,
+          sent: toolResult?.sent,
+          count: Array.isArray(toolResult?.results) ? toolResult.results.length : undefined
+        })), Math.floor(softLimit * 0.35))
+      });
+      break;
+
+    case 'spawn_subagent':
+      envelope = trimObject({
+        tool: toolName,
+        iterations: toolResult?.iterations,
+        tokens: toolResult?.tokens,
+        runId: toolResult?.runId,
+        summary: clampText(toolResult?.subagent_result || toolResult?.error || '', Math.floor(softLimit * 0.55))
+      });
+      break;
+
+    default:
+      envelope = trimObject({
+        tool: toolName,
+        summary: toJsonText(toolResult, Math.floor(softLimit * 0.75))
+      });
+      break;
+  }
+
+  return clampEnvelope(envelope, hardLimit);
+}
+
+module.exports = {
+  compactToolResult,
+  clampText,
+  lineExcerpt
+};

package/server/services/ai/toolRunner.js

@@ -1,8 +1,9 @@
 const fs = require('fs');
 const path = require('path');
 const db = require('../../db/database');
+const { AGENT_DATA_DIR } = require('../../../runtime/paths');
 
-const SKILLS_DIR = path.join(__dirname, '..', '..', '..', 'agent-data', 'skills');
+const SKILLS_DIR = path.join(AGENT_DATA_DIR, 'skills');
 
 class SkillRunner {
   constructor() {
@@ -86,7 +87,7 @@ class SkillRunner {
   }
 
   getSkillsForPrompt() {
-    const skills = Array.from(this.skills.values());
+    const skills = Array.from(this.skills.values()).filter((skill) => skill.metadata.enabled !== false);
     if (skills.length === 0) return '';
 
     let prompt = '\n## Available Skills\n';
@@ -102,7 +103,7 @@ class SkillRunner {
   getToolDefinitions() {
     const tools = [];
     for (const skill of this.skills.values()) {
-      if (skill.metadata.tool) {
+      if (skill.metadata.enabled !== false && skill.metadata.tool) {
         tools.push({
           name: skill.name,
           description: skill.description,
@@ -116,6 +117,9 @@ class SkillRunner {
   async executeTool(toolName, args) {
     const skill = this.skills.get(toolName);
     if (!skill) return null;
+    if (skill.metadata.enabled === false) {
+      return { error: `Skill '${toolName}' is disabled` };
+    }
 
     if (skill.metadata.command) {
       const { CLIExecutor } = require('../cli/executor');
@@ -139,8 +143,10 @@ class SkillRunner {
     const filePath = path.join(skillDir, 'SKILL.md');
     fs.writeFileSync(filePath, frontmatter + `\n\n${instructions}`);
 
-    db.prepare('INSERT OR REPLACE INTO skills (name, description, file_path, metadata, auto_created, updated_at) VALUES (?, ?, ?, ?, 1, datetime(\'now\'))')
-      .run(safeName, description, filePath, JSON.stringify(metadata));
+    db.prepare(`
+      INSERT OR REPLACE INTO skills (name, description, file_path, metadata, enabled, auto_created, updated_at)
+      VALUES (?, ?, ?, ?, ?, 1, datetime('now'))
+    `).run(safeName, description, filePath, JSON.stringify(metadata), metadata.enabled === false ? 0 : 1);
 
     this.loadSkillFile(filePath);
 
@@ -166,12 +172,24 @@ class SkillRunner {
 
     const frontmatter = this._buildFrontmatter(name, newDesc, metaToWrite);
     fs.writeFileSync(skill.filePath, frontmatter + `\n\n${newInstructions}`);
-    db.prepare('UPDATE skills SET description = ?, updated_at = datetime(\'now\') WHERE name = ?').run(newDesc, name);
+    db.prepare('UPDATE skills SET description = ?, metadata = ?, enabled = ?, updated_at = datetime(\'now\') WHERE name = ?')
+      .run(newDesc, JSON.stringify(metaToWrite || {}), metaToWrite?.enabled === false ? 0 : 1, name);
     this.loadSkillFile(skill.filePath);
 
     return { success: true, name, path: skill.filePath };
   }
 
+  getSkill(name) {
+    return this.skills.get(name) || null;
+  }
+
+  setSkillEnabled(name, enabled) {
+    const skill = this.skills.get(name);
+    if (!skill) return { error: `Skill '${name}' not found` };
+    const metadata = { ...skill.metadata, enabled: !!enabled };
+    return this.updateSkill(name, { metadata });
+  }
+
   deleteSkill(name) {
     const skill = this.skills.get(name);
     if (!skill) return { error: `Skill '${name}' not found` };
@@ -210,7 +228,8 @@ class SkillRunner {
       name: s.name,
       description: s.description,
       metadata: s.metadata,
-      filePath: s.filePath
+      filePath: s.filePath,
+      enabled: s.metadata.enabled !== false
     }));
   }
 }

package/server/services/ai/toolSelector.js

@@ -0,0 +1,140 @@
+const ALWAYS_ON_TOOLS = ['notify_user'];
+
+const PACKS = {
+  code: ['execute_command', 'read_file', 'list_directory', 'search_files'],
+  web: ['web_search', 'http_request', 'browser_navigate', 'browser_extract', 'browser_click', 'browser_type', 'browser_screenshot'],
+  messaging: ['send_message', 'make_call'],
+  memory: ['memory_recall', 'session_search', 'memory_save', 'memory_update_core', 'memory_read', 'memory_write'],
+  scheduling: ['create_scheduled_task', 'schedule_run', 'list_scheduled_tasks', 'update_scheduled_task', 'delete_scheduled_task'],
+  protocols: ['manage_protocols'],
+  skills: ['create_skill', 'list_skills', 'update_skill', 'delete_skill'],
+  images: ['generate_image', 'analyze_image'],
+  tables: ['generate_table', 'generate_graph'],
+  subagents: ['spawn_subagent'],
+  mcpAdmin: ['mcp_add_server', 'mcp_list_servers', 'mcp_remove_server']
+};
+
+function containsAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function detectRequestedPacks(task = '', options = {}) {
+  const text = String(task || '').toLowerCase();
+  const packs = new Set();
+
+  if (containsAny(text, [
+    /\b(run|execute|command|shell|terminal|bash|zsh|npm|node|python|script|repo|code|bug|fix|patch|test|build|file|folder|directory|grep|search files?)\b/,
+    /\b(read|open|inspect)\s+(the\s+)?(file|repo|code)\b/
+  ])) {
+    packs.add('code');
+  }
+
+  if (containsAny(text, [
+    /\b(web|website|url|page|browser|click|navigate|scrape|search|google|lookup|http|fetch|api request|screenshot)\b/,
+    /\bopen\b.*\bsite\b/
+  ])) {
+    packs.add('web');
+  }
+
+  if (containsAny(text, [
+    /\b(message|reply|respond|text|whatsapp|telegram|discord|dm|email|call|phone|notify|send to)\b/,
+    /\[no response\]/,
+    /\bsend_message\b/,
+    /\bmake_call\b/
+  ])) {
+    packs.add('messaging');
+  }
+
+  if (containsAny(text, [
+    /\bmemory\b/,
+    /\bremember\b/,
+    /\brecall\b/,
+    /\bprevious chat\b/,
+    /\blast time\b/,
+    /\bpast conversation\b/,
+    /\bpreference\b/,
+    /\bprofile\b/,
+    /\bsoul\b/
+  ])) {
+    packs.add('memory');
+  }
+
+  if (containsAny(text, [
+    /\bschedule\b/,
+    /\bcron\b/,
+    /\bremind\b/,
+    /\brecurring\b/,
+    /\bweekly\b/,
+    /\bdaily\b/,
+    /\bone-time\b/,
+    /\btask\b.*\blater\b/
+  ])) {
+    packs.add('scheduling');
+  }
+
+  if (containsAny(text, [/\bprotocol\b/, /\bplaybook\b/])) {
+    packs.add('protocols');
+  }
+
+  if (containsAny(text, [/\bskill\b/, /\binstall skill\b/, /\bcreate skill\b/])) {
+    packs.add('skills');
+  }
+
+  if (containsAny(text, [/\bimage\b/, /\bpicture\b/, /\bphoto\b/, /\bgraph\b/, /\bchart\b/, /\btable\b/, /\bqr\b/, /\bocr\b/])) {
+    packs.add('images');
+  }
+
+  if (containsAny(text, [/\btable\b/, /\bspreadsheet\b/, /\bgraph\b/, /\bchart\b/])) {
+    packs.add('tables');
+  }
+
+  if (containsAny(text, [/\bsub-?agent\b/, /\bdelegate\b/, /\bparallel\b/, /\bbackground worker\b/])) {
+    packs.add('subagents');
+  }
+
+  if (containsAny(text, [/\bmcp\b/, /\bmodel context protocol\b/, /\bserver tool\b/])) {
+    packs.add('mcpAdmin');
+  }
+
+  if (options.mediaAttachments?.length) {
+    packs.add('images');
+  }
+
+  return packs;
+}
+
+function maybeSelectMcpTools(text, mcpTools = []) {
+  const normalized = String(text || '').toLowerCase();
+  if (!normalized || !mcpTools.length) return [];
+
+  const explicitMcp = /\bmcp\b|\bmodel context protocol\b/.test(normalized);
+  return mcpTools.filter((tool) => {
+    const name = String(tool.name || '').toLowerCase();
+    const original = String(tool.originalName || '').toLowerCase();
+    const server = String(tool.serverId || '').toLowerCase();
+    return explicitMcp || normalized.includes(name) || normalized.includes(original) || (server && normalized.includes(server));
+  });
+}
+
+function selectToolsForTask(task, builtInTools = [], mcpTools = [], options = {}) {
+  const packs = detectRequestedPacks(task, options);
+  const allowNames = new Set(ALWAYS_ON_TOOLS);
+
+  for (const pack of packs) {
+    for (const toolName of PACKS[pack] || []) {
+      allowNames.add(toolName);
+    }
+  }
+
+  const selectedBuiltIns = builtInTools.filter((tool) => allowNames.has(tool.name));
+  const selectedMcp = maybeSelectMcpTools(task, mcpTools);
+
+  return [...selectedBuiltIns, ...selectedMcp];
+}
+
+module.exports = {
+  ALWAYS_ON_TOOLS,
+  PACKS,
+  detectRequestedPacks,
+  selectToolsForTask
+};

package/server/services/ai/tools.js

@@ -1,13 +1,56 @@
 const fs = require('fs');
 const path = require('path');
 const db = require('../../db/database');
+const { DATA_DIR } = require('../../../runtime/paths');
+
+function compactText(text, maxChars = 120) {
+  const str = String(text || '').replace(/\s+/g, ' ').trim();
+  if (str.length <= maxChars) return str;
+  const trimmed = str.slice(0, maxChars);
+  const sentenceBreak = Math.max(trimmed.lastIndexOf('. '), trimmed.lastIndexOf('; '), trimmed.lastIndexOf(', '));
+  if (sentenceBreak > 40) return trimmed.slice(0, sentenceBreak + 1).trim();
+  return `${trimmed.trim()}...`;
+}
+
+function compactToolDefinition(tool, options = {}) {
+  const compact = {
+    name: tool.name,
+    parameters: {
+      ...(tool.parameters || { type: 'object', properties: {} }),
+      properties: {}
+    }
+  };
+
+  if (options.includeDescriptions) {
+    compact.description = compactText(tool.description, 120);
+  }
+
+  if (tool.parameters?.properties) {
+    const properties = {};
+    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);
+      } else {
+        delete properties[key].description;
+      }
+    }
+    compact.parameters = {
+      ...compact.parameters,
+      properties
+    };
+  }
+
+  return compact;
+}
 
 /**
  * Returns the list of available tools for the agent.
  * @param {object} app - Express app instance.
+ * @param {object} options - Tool filtering options.
  * @returns {Array} List of tool definitions.
  */
-function getAvailableTools(app) {
+function getAvailableTools(app, options = {}) {
     const tools = [
         {
             name: 'execute_command',
@@ -99,6 +142,21 @@ function getAvailableTools(app) {
                 required: ['script']
             }
         },
+        {
+            name: 'web_search',
+            description: 'Search the public web without opening the browser. Uses Brave Search API for fast result retrieval.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search query to run' },
+                    count: { type: 'number', description: 'Maximum number of results to return (default 5, max 10)' },
+                    country: { type: 'string', description: 'Optional country code bias, e.g. "US", "DE", "GB"' },
+                    search_lang: { type: 'string', description: 'Optional search language code, e.g. "en", "de"' },
+                    freshness: { type: 'string', enum: ['pd', 'pw', 'pm', 'py'], description: 'Optional recency filter: past day, week, month, or year' }
+                },
+                required: ['query']
+            }
+        },
         {
             name: 'manage_protocols',
             description: 'Read, list, create, update, or delete text-based protocols (a pre-set list of instructions/actions). If user asks to execute a protocol, you should read it and follow its instructions.',
@@ -138,6 +196,18 @@ function getAvailableTools(app) {
                 required: ['query']
             }
         },
+        {
+            name: 'session_search',
+            description: 'Search past runs and message threads for commands, decisions, file paths, or context from earlier conversations.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'What to search for in prior sessions.' },
+                    limit: { type: 'number', description: 'How many matching sessions to return (default 6).' }
+                },
+                required: ['query']
+            }
+        },
         {
             name: 'memory_update_core',
             description: 'Update core memory — always-injected facts that appear in every prompt. Use for critical always-relevant info: user\'s name, their main job, key standing preferences, how they want you to behave. Keep each entry concise.',
@@ -514,7 +584,12 @@ function getAvailableTools(app) {
         }
     ];
 
-    return tools;
+    const compacted = tools.map((tool) => compactToolDefinition(tool, options));
+    if (options.names && Array.isArray(options.names)) {
+        const allow = new Set(options.names);
+        return compacted.filter((tool) => allow.has(tool.name));
+    }
+    return compacted;
 }
 
 /**
@@ -593,6 +668,74 @@ async function executeTool(toolName, args, context, engine) {
             return await controller.evaluate(args.script);
         }
 
+        case 'web_search': {
+            const apiKey = process.env.BRAVE_SEARCH_API_KEY;
+            if (!apiKey) return { error: 'BRAVE_SEARCH_API_KEY is not configured' };
+
+            const controller = new AbortController();
+            const timeoutMs = 20000;
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+            try {
+                const limit = Math.max(1, Math.min(Number(args.count) || 5, 10));
+                const params = new URLSearchParams({
+                    q: args.query,
+                    count: String(limit),
+                    text_decorations: 'false',
+                    result_filter: 'web'
+                });
+
+                if (args.country) params.set('country', String(args.country).toUpperCase());
+                if (args.search_lang) params.set('search_lang', String(args.search_lang).toLowerCase());
+                if (args.freshness) params.set('freshness', args.freshness);
+
+                const res = await fetch(`https://api.search.brave.com/res/v1/web/search?${params.toString()}`, {
+                    headers: {
+                        Accept: 'application/json',
+                        'X-Subscription-Token': apiKey
+                    },
+                    signal: controller.signal
+                });
+
+                const text = await res.text();
+                let data = null;
+                try {
+                    data = JSON.parse(text);
+                } catch {
+                    data = null;
+                }
+
+                if (!res.ok) {
+                    return {
+                        error: `Brave Search API request failed with status ${res.status}`,
+                        details: data || text.slice(0, 1000)
+                    };
+                }
+
+                const rawResults = Array.isArray(data?.web?.results) ? data.web.results : [];
+                const results = rawResults.slice(0, limit).map((item, index) => ({
+                    rank: index + 1,
+                    title: item.title || '',
+                    url: item.url || '',
+                    description: item.description || '',
+                    age: item.age || null,
+                    language: item.language || null,
+                    profile: item.profile?.long_name || item.profile?.name || null
+                }));
+
+                return {
+                    query: args.query,
+                    count: results.length,
+                    results
+                };
+            } catch (err) {
+                if (err.name === 'AbortError') return { error: `Brave Search API request timed out after ${timeoutMs} ms` };
+                return { error: err.message };
+            } finally {
+                clearTimeout(timer);
+            }
+        }
+
         case 'manage_protocols': {
             try {
                 if (args.action === 'list') {
@@ -641,6 +784,16 @@ async function executeTool(toolName, args, context, engine) {
             return { results };
         }
 
+        case 'session_search': {
+            const { MemoryManager } = require('../memory/manager');
+            const mm = new MemoryManager();
+            const results = mm.searchConversations(userId, args.query, {
+                sessions: args.limit || 6
+            });
+            if (!results.length) return { results: [], message: 'No matching sessions found' };
+            return { results };
+        }
+
         case 'memory_update_core': {
             const { MemoryManager } = require('../memory/manager');
             const mm = new MemoryManager();
@@ -686,13 +839,13 @@ async function executeTool(toolName, args, context, engine) {
                     const end = args.end_line || lines.length;
                     const sliced = lines.slice(start, end).join('\n');
                     return {
-                        content: sliced.length > 50000 ? sliced.slice(0, 50000) + '\n...[truncated]' : sliced,
+                        content: sliced.length > 20000 ? sliced.slice(0, 20000) + '\n...[truncated]' : sliced,
                         totalLines: lines.length,
                         rangeShown: [start + 1, Math.min(end, lines.length)]
                     };
                 }
                 const content = fs.readFileSync(args.path, encoding);
-                return { content: content.length > 50000 ? content.slice(0, 50000) + '\n...[truncated]' : content };
+                return { content: content.length > 20000 ? content.slice(0, 20000) + '\n...[truncated]' : content };
             } catch (err) {
                 return { error: err.message };
             }
@@ -1000,7 +1153,7 @@ async function executeTool(toolName, args, context, engine) {
                     n: count,
                     response_format: 'b64_json'
                 });
-                const MEDIA_DIR = path.join(__dirname, '..', '..', '..', 'data', 'media');
+                const MEDIA_DIR = path.join(DATA_DIR, 'media');
                 if (!fs.existsSync(MEDIA_DIR)) fs.mkdirSync(MEDIA_DIR, { recursive: true });
                 const savedPaths = [];
                 for (const img of result.data) {