neuralos 3.3.8 → 3.4.0

package/bin/gybackend.cjs

@@ -350712,12 +350712,12 @@ var BUILTIN_TOOL_INFO = [
   {
     name: "write_file",
     description: WRITE_FILE_TOOL_DESCRIPTION,
-    hiddenFromSettings: true
+    shortDescription: "Write a full file (replace contents)"
   },
   {
     name: "edit_file",
     description: EDIT_FILE_TOOL_DESCRIPTION,
-    hiddenFromSettings: true
+    shortDescription: "Edit a file by replacing an exact string"
   },
   {
     name: "skill",
@@ -354867,6 +354867,7 @@ var CORE_METHODS = [
   m("tools:getMcp", "tools", "List MCP tools.", "1.0.0"),
   m("tools:setMcpEnabled", "tools", "Enable/disable an MCP tool.", "1.0.0"),
   m("tools:getBuiltIn", "tools", "List built-in agent tools with enabled state.", "1.0.0"),
+  m("tools:getPlugins", "tools", "List plugin agent tools (name, plugin, description).", "3.4.0"),
   m("tools:setBuiltInEnabled", "tools", "Enable/disable a built-in tool.", "1.0.0", { name: { type: "string" }, enabled: { type: "boolean" } })
 ];
 var DESCRIBE_METHOD = m(
@@ -369458,6 +369459,7 @@ var AgentService_v2 = class {
   pluginTools = /* @__PURE__ */ new Map();
   /** Plugin tool schemas (for toolsForModel injection). */
   pluginToolSchemas = [];
+  pluginToolMeta = [];
   passChatTempExportService = new PassChatTempExportService();
   fallbackCompactionHistoryExportService = null;
   activeAgentRunIdsBySession = /* @__PURE__ */ new Map();
@@ -369516,11 +369518,35 @@ var AgentService_v2 = class {
    * pluginTools (so the dispatch switch's default case can call them). */
   setPluginTools(tools2) {
     this.pluginTools = new Map(tools2.map((t) => [t.name, t.handler]));
-    this.pluginToolSchemas = tools2.map((t) => ({
+    this.pluginToolMeta = tools2.map((t) => ({
       name: t.name,
-      description: t.description,
-      schema: t.params || {}
+      description: t.description || t.name,
+      plugin: t.plugin || "plugin"
     }));
+    this.pluginToolSchemas = tools2.map((t) => {
+      const params = t.params && typeof t.params === "object" ? t.params : {};
+      const looksJsonSchema = typeof params.type === "string";
+      const parameters = looksJsonSchema ? params : {
+        type: "object",
+        properties: params,
+        additionalProperties: true
+      };
+      return {
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description || t.name,
+          parameters
+        }
+      };
+    });
+  }
+  /** Plugin tools in OpenAI bindTools shape (empty until setPluginTools). */
+  getPluginToolSchemas() {
+    return this.pluginToolSchemas;
+  }
+  listPluginTools() {
+    return this.pluginToolMeta.map((t) => ({ ...t, enabled: true }));
   }
   /** Wire a session-log handle so list_session_logs / read_session_log work. */
   setSessionLogger(logger) {
@@ -370142,9 +370168,11 @@ var AgentService_v2 = class {
         }
       );
       const baseModel = shouldUseThinkingModelOnThisPass ? sessionBinding.thinkingModel || sessionBinding.model : sessionBinding.model;
+      const pluginOpenAiTools = this.pluginToolSchemas;
       const modelWithTools = baseModel.bindTools([
         ...builtInTools,
-        ...mcpTools
+        ...mcpTools,
+        ...pluginOpenAiTools
       ]);
       const messageId = v4_default();
       let partialText = "";
@@ -370180,7 +370208,11 @@ var AgentService_v2 = class {
             shouldUseThinkingModelOnThisPass ? 0.2 : 0.7,
             null
           );
-          modelToUse = fallbackChat.bindTools([...builtInTools, ...mcpTools]);
+          modelToUse = fallbackChat.bindTools([
+            ...builtInTools,
+            ...mcpTools,
+            ...pluginOpenAiTools
+          ]);
         }
         return await invokeWithRetryAndSanitizedInput({
           helpers: this.helpers,
@@ -376649,6 +376681,15 @@ var WebSocketGatewayAdapter = class {
         }
         return await this.options.toolsBridge.getBuiltIn();
       }
+      case "tools:getPlugins": {
+        if (!this.options.toolsBridge?.getPlugins) {
+          throw new WebSocketRpcError(
+            "METHOD_NOT_FOUND",
+            "tools:getPlugins is not available on this websocket gateway."
+          );
+        }
+        return await this.options.toolsBridge.getPlugins();
+      }
       case "tools:setBuiltInEnabled": {
         if (!this.options.toolsBridge?.setBuiltInEnabled) {
           throw new WebSocketRpcError(
@@ -392577,6 +392618,23 @@ var PluginRegistry = class {
   allTools() {
     return this.list().filter((p) => p.enabled && !p.error).flatMap((p) => p.tools);
   }
+  /** Flatten enabled plugin tools for AgentService.setPluginTools. */
+  collectAgentTools() {
+    const out = [];
+    for (const record2 of this.list()) {
+      if (record2.error || !record2.enabled) continue;
+      for (const tool2 of record2.tools) {
+        out.push({
+          name: tool2.name,
+          description: tool2.description ?? "",
+          params: tool2.params ?? {},
+          handler: tool2.handler,
+          plugin: record2.manifest.name
+        });
+      }
+    }
+    return out;
+  }
   /** All triggers from enabled plugins. */
   allTriggers() {
     return this.list().filter((p) => p.enabled && !p.error).flatMap((p) => p.triggers);
@@ -398016,25 +398074,15 @@ async function startGyBackend() {
   Promise.race([
     observability.pluginRegistry.reload(),
     new Promise((_, reject) => setTimeout(() => reject(new Error("plugin reload timeout (10s)")), 1e4))
-  ]).then((pluginRecords) => {
-    const pluginTools = [];
-    for (const record2 of pluginRecords) {
-      if (record2.error || !record2.enabled) continue;
-      for (const tool2 of record2.tools) {
-        pluginTools.push({
-          name: tool2.name,
-          description: tool2.description ?? "",
-          params: tool2.params ?? {},
-          handler: tool2.handler
-        });
-      }
-    }
-    if (pluginTools.length > 0) {
-      agentService.setPluginTools(pluginTools);
-      console.log(`[gybackend] Wired ${pluginTools.length} plugin tools from ${pluginRecords.filter((r) => !r.error && r.enabled).length} plugins into the agent.`);
-    } else {
-      console.log("[gybackend] No plugin tools found to wire.");
+  ]).then(() => {
+    const pluginTools = observability.pluginRegistry.collectAgentTools();
+    agentService.setPluginTools(pluginTools);
+    const enabled = observability.pluginRegistry.list().filter((r) => !r.error && r.enabled).length;
+    try {
+      gatewayService.broadcastRaw("tools:pluginsUpdated", agentService.listPluginTools());
+    } catch {
     }
+    console.log(`[gybackend] Wired ${pluginTools.length} plugin tools from ${enabled} plugins into the agent.`);
   }).catch((e) => {
     console.warn("[gybackend] Plugin tool wiring skipped:", e instanceof Error ? e.message : String(e));
   });
@@ -398698,6 +398746,7 @@ async function startGyBackend() {
             const settings = settingsService.getSettings();
             return buildBuiltInToolStatusSummary(settings.tools?.builtIn);
           },
+          getPlugins: () => agentService.listPluginTools(),
           setBuiltInEnabled: async (name, enabled) => {
             const settings = settingsService.getSettings();
             const nextBuiltIn = { ...settings.tools?.builtIn ?? {} };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuralos",
-  "version": "3.3.8",
+  "version": "3.4.0",
   "description": "AI-native terminal & agentic-AI operations platform for Forward Deployed Engineers & SREs: AIOps closed-loop remediation, AI SRE, self-healing infrastructure, runbook automation, ChatOps; executes over SSH/WinRM/serial under policy with tamper-evident audit.",
   "keywords": [
     "forward-deployed-engineer",

package/plugins/monid-bridge/index.mjs

@@ -1,12 +1,16 @@
 /**
- * monid-bridge — thin wrapper around the official Monid CLI.
+ * monid-bridge — thin wrapper around the official Monid CLI (v0.1.6).
  *
- * Settings → Plugins → Monid (settings.monid):
- *   enabled, binaryPath, keyLabel
- * The API key is NEVER stored in settings.json. Saving a key in the UI runs
- * `monid keys add -k <key> -l <label>` (see applyMonidApiKey).
+ * Settings → Plugins → Monid (settings.monid): enabled, binaryPath, keyLabel
+ * API key is NEVER stored in settings.json (`monid keys add -k … -l …`).
  *
- * Agent tools: monid_health, monid_discover, monid_run.
+ * Agent tools: monid_health, monid_discover, monid_inspect, monid_run.
+ *
+ * Argv MUST match `monid <cmd> --help`:
+ *   discover --query <q> [--limit n] [--min-score s] --json
+ *   inspect  --provider <p> --endpoint <e> --json
+ *   run      --provider <p> --endpoint <e> [--input json] [--query json] [--path json] --json
+ * Bare `discover <query>` / `run <tool>` are false positives (CLI rejects them).
  */
 
 import { createRequire } from 'node:module'
@@ -23,25 +27,80 @@ export function resolveConfig(ctx = {}, env = process.env) {
   }
 }
 
-/** Build argv for a monid subcommand. Pure. */
+function reqStr(v, name) {
+  const s = String(v ?? '').trim()
+  if (!s) throw new Error(`${name} is required`)
+  return s
+}
+
+function optJsonFlag(argv, flag, value) {
+  if (value == null) return
+  const s = typeof value === 'string' ? value.trim() : JSON.stringify(value)
+  if (!s) return
+  argv.push(flag, s)
+}
+
+function optNumFlag(argv, flag, value) {
+  if (value == null || value === '') return
+  const n = Number(value)
+  if (!Number.isFinite(n)) throw new Error(`${flag} must be a number`)
+  argv.push(flag, String(n))
+}
+
+/**
+ * Build argv AFTER the binary name.
+ * Always pass --json so agents get structured output (no ANSI).
+ */
 export function buildMonidArgv(sub, params = {}) {
   switch (sub) {
     case 'version':
       return ['--version']
     case 'keys-list':
       return ['keys', 'list']
+    case 'whoami':
+      return ['whoami']
     case 'discover': {
-      const q = String(params.query || '').trim()
-      if (!q) throw new Error('monid_discover needs a query')
-      return ['discover', q]
+      const q = reqStr(params.query, 'query')
+      const argv = ['discover', '--query', q]
+      optNumFlag(argv, '--limit', params.limit)
+      optNumFlag(argv, '--min-score', params.minScore ?? params['min-score'])
+      argv.push('--json')
+      return argv
+    }
+    case 'inspect': {
+      const provider = reqStr(params.provider, 'provider')
+      const endpoint = reqStr(params.endpoint, 'endpoint')
+      return ['inspect', '--provider', provider, '--endpoint', endpoint, '--json']
     }
     case 'run': {
+      // FN: agents may pass tool="provider/endpoint" from older docs.
+      let provider = String(params.provider || '').trim()
+      let endpoint = String(params.endpoint || '').trim()
       const tool = String(params.tool || '').trim()
-      if (!tool) throw new Error('monid_run needs a tool name')
-      const argv = ['run', tool]
-      if (params.input != null && String(params.input).trim()) {
-        argv.push('--input', String(params.input))
+      if ((!provider || !endpoint) && tool) {
+        const slash = tool.indexOf('/')
+        if (slash > 0) {
+          provider = provider || tool.slice(0, slash)
+          endpoint = endpoint || tool.slice(slash)
+        }
+      }
+      if (!provider) throw new Error('monid_run needs provider (slug from discover)')
+      if (!endpoint) throw new Error('monid_run needs endpoint (path from discover, e.g. /news/search)')
+      if (!endpoint.startsWith('/')) {
+        throw new Error('endpoint must start with / (Monid endpoint path, not a free-form tool name)')
+      }
+      const argv = ['run', '--provider', provider, '--endpoint', endpoint]
+      const input = params.input ?? params.body
+      if (input != null && String(input).trim()) {
+        argv.push('--input', typeof input === 'string' ? input : JSON.stringify(input))
       }
+      optJsonFlag(argv, '--query', params.queryParams ?? params.query)
+      optJsonFlag(argv, '--path', params.pathParams ?? params.path)
+      if (params.wait != null && params.wait !== false && params.wait !== '') {
+        argv.push('--wait')
+        if (params.wait !== true) argv.push(String(params.wait))
+      }
+      argv.push('--json')
       return argv
     }
     default:
@@ -49,21 +108,30 @@ export function buildMonidArgv(sub, params = {}) {
   }
 }
 
+/** True if argv looks like the broken 3.3.8 shapes (for tests / guards). */
+export function isLegacyBrokenArgv(argv) {
+  if (!Array.isArray(argv) || argv.length < 2) return false
+  if (argv[0] === 'discover' && argv[1] !== '--query' && !argv[1].startsWith('-')) return true
+  if (argv[0] === 'run' && argv[1] !== '--provider' && !String(argv[1]).startsWith('-')) return true
+  return false
+}
+
 async function runMonid(ctx, cfg, argv) {
+  const env = { ...process.env, NO_COLOR: '1' }
   if (typeof ctx.runCommand === 'function') {
-    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ')
-    return ctx.runCommand({ command: cmdline })
+    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? JSON.stringify(a) : a)).join(' ')
+    return ctx.runCommand({ command: cmdline, env })
   }
   if (typeof ctx.exec === 'function') {
-    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ')
-    return ctx.exec(cmdline)
+    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? JSON.stringify(a) : a)).join(' ')
+    return ctx.exec(cmdline, { env })
   }
   const { execFile } = require('node:child_process')
   return new Promise((resolve) => {
-    execFile(cfg.binaryPath, argv, { timeout: 120000, env: { ...process.env, NO_COLOR: '1' } }, (err, stdout, stderr) => {
+    execFile(cfg.binaryPath, argv, { timeout: 120000, env }, (err, stdout, stderr) => {
       resolve({
         ok: !err,
-        exitCode: err?.code ?? 0,
+        exitCode: typeof err?.code === 'number' ? err.code : err ? 1 : 0,
         stdout: String(stdout ?? ''),
         stderr: String(stderr ?? ''),
         error: err ? String(err.message) : undefined,
@@ -80,7 +148,7 @@ async function guarded(fn, log) {
     log?.(`[monid] ${msg}`)
     return {
       error: msg,
-      hint: 'Install @monid-ai/cli (`npm i -g @monid-ai/cli`) and paste an API key in Settings → Plugins → Monid (https://app.monid.ai/access/api-keys).',
+      hint: 'Install @monid-ai/cli (`npm i -g @monid-ai/cli`) and paste an API key in Settings → Plugins → Monid. discover needs --query; run needs --provider and --endpoint.',
     }
   }
 }
@@ -101,15 +169,19 @@ export function register(ctx) {
       guarded(async () => {
         const ver = await runMonid(ctx, cfg, buildMonidArgv('version'))
         const keys = await runMonid(ctx, cfg, buildMonidArgv('keys-list'))
-        return { binaryPath: cfg.binaryPath, keyLabel: cfg.keyLabel, version: ver, keys }
+        const who = await runMonid(ctx, cfg, buildMonidArgv('whoami'))
+        return { binaryPath: cfg.binaryPath, keyLabel: cfg.keyLabel, version: ver, keys, whoami: who }
       }, log),
   })
 
   registerTool({
     name: 'monid_discover',
-    description: 'Discover Monid tools/endpoints for a task (web data, enrichment, social, company/people). Use before writing a scraper or when a generic fetch is not enough.',
+    description:
+      'Search Monid data endpoints with natural language (company news, people, enrichment). Uses `monid discover --query`. Do not pass a bare positional query.',
     params: {
-      query: { type: 'string', description: 'What you need (e.g. "linkedin company employees")' },
+      query: { type: 'string', description: 'Natural-language search (required)' },
+      limit: { type: 'number', description: 'Max results (max 50)', optional: true },
+      minScore: { type: 'number', description: 'Minimum relevance score', optional: true },
     },
     handler: async (p) =>
       guarded(async () => {
@@ -119,12 +191,32 @@ export function register(ctx) {
       }, log),
   })
 
+  registerTool({
+    name: 'monid_inspect',
+    description: 'Get full details for one Monid endpoint (`monid inspect --provider --endpoint`).',
+    params: {
+      provider: { type: 'string', description: 'Provider slug (e.g. context.dev)' },
+      endpoint: { type: 'string', description: 'Endpoint path (e.g. /news/search)' },
+    },
+    handler: async (p) =>
+      guarded(async () => {
+        const argv = buildMonidArgv('inspect', p)
+        const r = await runMonid(ctx, cfg, argv)
+        return { argv: [cfg.binaryPath, ...argv], ...r }
+      }, log),
+  })
+
   registerTool({
     name: 'monid_run',
-    description: 'Run a named Monid tool with optional JSON/text input. Prefer this over hand-rolled scrapers when discover returned a tool.',
+    description:
+      'Execute a Monid endpoint (`monid run --provider --endpoint`). provider+endpoint from discover; optional JSON --input / --query / --path. Not `monid run <toolName>`.',
     params: {
-      tool: { type: 'string', description: 'Tool name from monid_discover' },
-      input: { type: 'string', description: 'JSON or text input for the tool', optional: true },
+      provider: { type: 'string', description: 'Provider slug', optional: true },
+      endpoint: { type: 'string', description: 'Endpoint path starting with /', optional: true },
+      tool: { type: 'string', description: 'Optional shorthand provider/endpoint', optional: true },
+      input: { type: 'string', description: 'Body JSON string', optional: true },
+      queryParams: { type: 'string', description: 'Query-parameters JSON string', optional: true },
+      pathParams: { type: 'string', description: 'Path-parameters JSON string', optional: true },
     },
     handler: async (p) =>
       guarded(async () => {

package/plugins/monid-bridge/monid-bridge.extreme.spec.mjs

@@ -1,27 +1,75 @@
-import { buildMonidArgv, resolveConfig } from './index.mjs'
+import { buildMonidArgv, isLegacyBrokenArgv, resolveConfig } from './index.mjs'
 
 const assert = (c, m) => {
   if (!c) throw new Error(`assert failed: ${m}`)
 }
 
+// --- config ---
 assert(resolveConfig({ settings: {} }).enabled === true, 'enabled default')
 assert(resolveConfig({ settings: { monid: { enabled: false } } }).enabled === false, 'disabled')
 assert(resolveConfig({ settings: { monid: { binaryPath: '/opt/monid' } } }).binaryPath === '/opt/monid', 'bin')
 assert(resolveConfig({}, { MONID_BIN: 'custom-monid' }).binaryPath === 'custom-monid', 'env bin')
 
+// --- FP: 3.3.8 positional argv must be detected as broken ---
+assert(isLegacyBrokenArgv(['discover', 'company news']) === true, 'FP discover positional')
+assert(isLegacyBrokenArgv(['run', 'foo']) === true, 'FP run positional')
+assert(isLegacyBrokenArgv(['discover', '--query', 'company news']) === false, 'good discover')
+assert(isLegacyBrokenArgv(['run', '--provider', 'x', '--endpoint', '/y']) === false, 'good run')
+
+const disc = buildMonidArgv('discover', { query: 'company news', limit: 5 })
+assert(!isLegacyBrokenArgv(disc), 'new discover not legacy')
+assert(disc[0] === 'discover' && disc[1] === '--query' && disc[2] === 'company news', `disc=${disc}`)
+assert(disc.includes('--limit') && disc.includes('5') && disc.includes('--json'), 'limit+json')
+
 assert(buildMonidArgv('version').join(' ') === '--version', 'version')
 assert(buildMonidArgv('keys-list').join(' ') === 'keys list', 'keys list')
-assert(buildMonidArgv('discover', { query: 'company news' }).join(' ') === 'discover company news', 'discover')
-assert(buildMonidArgv('run', { tool: 'foo', input: '{"a":1}' }).join(' ') === 'run foo --input {"a":1}', 'run')
+assert(buildMonidArgv('whoami').join(' ') === 'whoami', 'whoami')
+
+const insp = buildMonidArgv('inspect', { provider: 'context.dev', endpoint: '/news/search' })
+assert(insp.join(' ') === 'inspect --provider context.dev --endpoint /news/search --json', insp.join(' '))
+
+const run = buildMonidArgv('run', {
+  provider: 'context.dev',
+  endpoint: '/news/search',
+  input: '{"q":"acme"}',
+})
+assert(run[0] === 'run' && run.includes('--provider') && run.includes('context.dev'), 'run provider')
+assert(run.includes('--endpoint') && run.includes('/news/search'), 'run endpoint')
+assert(run.includes('--input') && run.includes('--json'), 'run input+json')
+assert(!isLegacyBrokenArgv(run), 'new run not legacy')
+
+// FN: tool="provider/endpoint" shorthand
+const fromTool = buildMonidArgv('run', { tool: 'apollo/mixed_companies/search' })
+assert(fromTool.includes('apollo') && fromTool.includes('/mixed_companies/search'), `fromTool=${fromTool}`)
 
+// FN: queryParams / pathParams
+const withQP = buildMonidArgv('run', {
+  provider: 'akta',
+  endpoint: '/v1/news',
+  queryParams: '{"q":"x"}',
+  pathParams: '{"id":"1"}',
+})
+assert(withQP.includes('--query') && withQP.includes('{"q":"x"}'), 'query flag')
+assert(withQP.includes('--path') && withQP.includes('{"id":"1"}'), 'path flag')
+
+// rejects
 let threw = false
-try { buildMonidArgv('discover', { query: '' }) } catch { threw = true }
-assert(threw, 'discover requires query')
+try { buildMonidArgv('discover', { query: '  ' }) } catch { threw = true }
+assert(threw, 'empty query')
+threw = false
+try { buildMonidArgv('run', { tool: 'not-a-path' }) } catch { threw = true }
+assert(threw, 'run without provider/endpoint')
 threw = false
-try { buildMonidArgv('run', {}) } catch { threw = true }
-assert(threw, 'run requires tool')
+try { buildMonidArgv('run', { provider: 'x', endpoint: 'news' }) } catch { threw = true }
+assert(threw, 'endpoint must start with /')
+threw = false
+try { buildMonidArgv('inspect', { provider: 'x' }) } catch { threw = true }
+assert(threw, 'inspect needs endpoint')
 threw = false
 try { buildMonidArgv('nope') } catch { threw = true }
 assert(threw, 'unknown sub')
+threw = false
+try { buildMonidArgv('discover', { query: 'q', limit: 'nope' }) } catch { threw = true }
+assert(threw, 'bad limit')
 
 console.log('monid-bridge: all cases passed')

package/plugins/monid-bridge/plugin.json

@@ -6,6 +6,7 @@
   "tools": [
     "monid_health",
     "monid_discover",
+    "monid_inspect",
     "monid_run"
   ],
   "permissions": [