neuralos 3.2.2 → 3.2.5

package/bin/gybackend.cjs

@@ -296885,6 +296885,13 @@ ${res.stderr}` : "")
     task2.endTime = Date.now();
     task2.exitCode = options?.exitCode;
     task2.endOffset = task2.startOffset + task2.output.length;
+    if (task2.capturedOutput !== void 0 && task2.capturedOutput.length < (task2.output || "").length) {
+      task2.captureStatus = "partial";
+    } else if ((task2.output || "").length > MAX_BUFFER_SIZE) {
+      task2.captureStatus = "display-truncated";
+    } else {
+      task2.captureStatus = "complete";
+    }
     this.stopCommandTrackingWatcher(taskId);
     this.activeTaskByTerminal.delete(terminalId);
     this.pendingTaskFinishByTerminal.delete(terminalId);
@@ -296899,7 +296906,8 @@ ${res.stderr}` : "")
       callback({
         stdoutDelta: task2.output,
         exitCode: options?.exitCode,
-        history_command_match_id: taskId
+        history_command_match_id: taskId,
+        captureStatus: task2.captureStatus
       });
     }
   }
@@ -349593,10 +349601,11 @@ async function runCommand(args, context2, options) {
       });
       finalResult = `The command has been running for over 120s and has been switched to nowait mode (running in the background). You can use read_command_output to check its progress. history_command_match_id=${historyCommandMatchId}, terminalId=${bestMatch.id}`;
     } else {
+      const captureNote = result.captureStatus === "partial" ? "\n[Note: Some output may have been lost during capture. Use read_command_output to retrieve the full output if needed.]" : result.captureStatus === "display-truncated" ? "\n[Note: Output was truncated for display. Use read_command_output to retrieve the full output if needed.]" : "";
       finalResult = `The command has finished executing. The following is the output (history_command_match_id=${historyCommandMatchId}):
 <terminal_content>
 ${truncatedOutput}
-</terminal_content>`;
+</terminal_content>${captureNote}`;
     }
     context2.sendEvent(sessionId, {
       messageId,
@@ -367392,6 +367401,114 @@ var SINGLE_CALL_TOOL_BOUNDARY_NAMES = /* @__PURE__ */ new Set([
   "manage_template",
   "import_putty"
 ]);
+var PARALLEL_SAFE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "read_file",
+  "read_terminal_tab",
+  "read_command_output",
+  "list_session_logs",
+  "read_session_log",
+  "search_session_logs",
+  "get_metrics",
+  "get_live_dashboard",
+  "get_monitor_status",
+  "get_cloud_inventory",
+  "get_apm_summary",
+  "get_dem_summary",
+  "get_cost",
+  "get_run_ledger",
+  "list_gateway_methods",
+  "manage_secret",
+  // read operations (list/has) are safe; set/delete are rare
+  "manage_oncall",
+  // open_pages is read-only
+  "manage_gitops",
+  // export/drift/inSync are read-only
+  "manage_playbook_version",
+  // lint/history/diff are read-only
+  "collect_facts",
+  "run_fleet_command",
+  // runs on different terminals — parallel-safe
+  "synapse_health",
+  "synapse_discover",
+  "synapse_agents_summary",
+  "synapse_reputation",
+  "synapse_serve_status",
+  "numbat_health",
+  "numbat_findings_summary",
+  "agentspan_health",
+  "agentspan_list",
+  "agentspan_status",
+  "webintel_health",
+  "web_search",
+  "web_fetch",
+  "web_find_similar",
+  "web_watch_list",
+  "patch_status",
+  "list_requests",
+  "request_status",
+  "sop_search",
+  "sop_get",
+  "iam_user_info",
+  "iam_user_groups",
+  "iam_access_review",
+  "fraudops_pipeline_status",
+  "fraudops_str_status",
+  "fraudops_decision_summary",
+  "netdata_alert_summary",
+  "netdata_correlate"
+]);
+function canRunInParallel(toolCalls) {
+  if (toolCalls.length <= 1) return false;
+  for (const tc of toolCalls) {
+    if (SINGLE_CALL_TOOL_BOUNDARY_NAMES.has(tc?.name)) return false;
+    if (!PARALLEL_SAFE_TOOL_NAMES.has(tc?.name)) return false;
+  }
+  const terminalIds = /* @__PURE__ */ new Set();
+  for (const tc of toolCalls) {
+    const args = typeof tc?.args === "string" ? (() => {
+      try {
+        return JSON.parse(tc.args);
+      } catch {
+        return {};
+      }
+    })() : tc?.args || {};
+    const tid = args.terminalId || args.target;
+    if (tid) {
+      if (terminalIds.has(tid)) return false;
+      terminalIds.add(tid);
+    }
+  }
+  return true;
+}
+function reconcileToolCalls(toolCalls) {
+  if (!Array.isArray(toolCalls) || toolCalls.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const tc of toolCalls) {
+    if (!tc || typeof tc !== "object") continue;
+    if (!tc.name || typeof tc.name !== "string") continue;
+    let args = tc.args;
+    if (args == null) {
+      args = {};
+    } else if (typeof args === "string") {
+      try {
+        args = JSON.parse(args);
+      } catch {
+        args = {};
+      }
+    }
+    const id = tc.id || "";
+    if (id) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+    }
+    const dedupKey = `${tc.name}::${JSON.stringify(args)}`;
+    if (seen.has(dedupKey)) continue;
+    seen.add(dedupKey);
+    result.push({ ...tc, args });
+  }
+  return result;
+}
 function clipTextMiddle(input, maxChars) {
   if (maxChars <= 0) return "";
   if (input.length <= maxChars) return input;
@@ -368358,7 +368475,9 @@ var AgentService_v2 = class {
       if (!AIMessage.isInstance(lastMessage)) {
         return { messages, sessionId, pendingToolCalls };
       }
-      const toolCalls = Array.isArray(lastMessage.tool_calls) ? lastMessage.tool_calls : [];
+      const toolCalls = reconcileToolCalls(
+        Array.isArray(lastMessage.tool_calls) ? lastMessage.tool_calls : []
+      );
       if (!toolCalls || toolCalls.length === 0) {
         this.cleanupModelToolCallMetadata(lastMessage, []);
         return { messages, sessionId, pendingToolCalls };
@@ -368393,6 +368512,31 @@ var AgentService_v2 = class {
       if (!sessionId) throw new Error("No session ID in state");
       const sessionBinding = this.getSessionModelBinding(sessionId);
       const queue2 = Array.isArray(state.pendingToolCalls) ? state.pendingToolCalls : [];
+      if (canRunInParallel(queue2)) {
+        const parallelResults = await Promise.all(
+          queue2.map(async (tc) => {
+            const tm = this.createToolMessage(tc);
+            const ec = this.createExecutionContext(
+              sessionId,
+              tm.additional_kwargs._gyshellMessageId,
+              config2
+            );
+            let res = "";
+            try {
+              res = await this.executeToolByName(tc, ec);
+            } catch (err) {
+              res = `Parallel execution error for ${tc.name}: ${err.message}`;
+            }
+            tm.content = res;
+            return tm;
+          })
+        );
+        return {
+          messages: [...state.messages, ...parallelResults],
+          sessionId,
+          pendingToolCalls: []
+        };
+      }
       const toolCall = queue2[0];
       if (!toolCall) return state;
       const toolMessage = this.createToolMessage(toolCall);
@@ -369245,6 +369389,71 @@ Actually, your intention might be different. Please re-read the description of t
       };
     });
   }
+  /** v3.2.4: Execute a single tool by name (used by the parallel execution path).
+   * This is a simplified dispatch that handles the common read-only/parallel-safe tools.
+   * Tools not handled here fall back to the sequential switch/case path. */
+  async executeToolByName(toolCall, executionContext) {
+    const name = toolCall.name;
+    const args = typeof toolCall.args === "string" ? (() => {
+      try {
+        return JSON.parse(toolCall.args);
+      } catch {
+        return {};
+      }
+    })() : toolCall.args || {};
+    const ti = toolImplementations;
+    switch (name) {
+      case "read_terminal_tab":
+        return ti.readTerminalTab(args, executionContext);
+      case "read_command_output":
+        return ti.readCommandOutput(args, executionContext);
+      case "list_session_logs":
+        return ti.listSessionLogs(args, executionContext);
+      case "read_session_log":
+        return ti.readSessionLog(args, executionContext);
+      case "search_session_logs":
+        return ti.searchSessionLogs(args, executionContext);
+      case "get_metrics":
+        return ti.getMetrics(args, executionContext);
+      case "get_live_dashboard":
+        return ti.getLiveDashboard(args, executionContext);
+      case "get_monitor_status":
+        return ti.getMonitorStatus(args, executionContext);
+      case "get_cloud_inventory":
+        return ti.getCloudInventory(args, executionContext);
+      case "get_apm_summary":
+        return ti.getApmSummary(args, executionContext);
+      case "get_dem_summary":
+        return ti.getDemSummary(args, executionContext);
+      case "get_cost":
+        return ti.getCost(args, executionContext);
+      case "get_run_ledger":
+        return ti.getRunLedger(args, executionContext);
+      case "list_gateway_methods":
+        return ti.listGatewayMethods(args, executionContext);
+      case "collect_facts":
+        return ti.collectFacts(args, executionContext);
+      case "run_fleet_command":
+        return ti.runFleetCommand(args, executionContext);
+      case "manage_secret":
+        return ti.manageSecret(args, executionContext);
+      case "manage_oncall":
+        return ti.manageOncall(args, executionContext);
+      case "manage_gitops":
+        return ti.manageGitops(args, executionContext);
+      case "manage_playbook_version":
+        return ti.managePlaybookVersion(args, executionContext);
+      // Plugin tools — delegate to the pluginTools map
+      default: {
+        const pluginHandler = this.pluginTools.get(name);
+        if (pluginHandler) {
+          const result = await pluginHandler(args);
+          return typeof result === "string" ? result : JSON.stringify(result);
+        }
+        return `Tool "${name}" is not supported in parallel execution mode.`;
+      }
+    }
+  }
   createReadFileNode() {
     return RunnableLambda.from(async (state, config2) => {
       const sessionId = state.sessionId;
@@ -370593,12 +370802,20 @@ ${reminder}`;
         lastCheckpointOffset: 0,
         lastProfileMaxTokens: this.getEffectiveMaxTokensForSession(sessionId)
       };
+      const previousFrontier = session.lastCheckpointOffset || 0;
+      const newFrontier = messages.length;
       this.updateSessionFromMessages(
         session,
         messages,
         this.getEffectiveMaxTokensForSession(sessionId)
       );
+      session.lastCheckpointOffset = newFrontier;
       this.chatHistoryService.saveSession(session);
+      if (newFrontier !== previousFrontier) {
+        console.log(
+          `[AgentService_v2] Reading frontier updated: ${previousFrontier} -> ${newFrontier} messages (session ${sessionId}).`
+        );
+      }
     } catch (error40) {
       console.warn(
         "[AgentService_v2] Failed to save session from checkpoint:",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "neuralos",
-  "version": "3.2.2",
-  "description": "Headless AI-native backend for RTerm / neuralOS — v3.2.2: 5 edge case fixes (session-busy race, heavy output batching, stop-during-approval, stop debounce, write-retry limit). 11 plugins, 55 plugin tools wired. Transports (SSH/serial/local), SQLite, and NATS libs install automatically.",
+  "version": "3.2.5",
+  "description": "Headless AI-native backend for RTerm / neuralOS — v3.2.5: captureStatus (complete/partial/truncated), reconcileToolCalls (streamed multi-tool validation), reading frontier for emergency recovery. 11 plugins, 55 plugin tools wired. Transports (SSH/serial/local), SQLite, and NATS libs install automatically.",
   "main": "bin/gybackend.cjs",
   "bin": { "gybackend": "bin/gybackend.cjs" },
   "license": "MIT",