neuralos 3.3.9 → 3.4.1

package/bin/gybackend.cjs

@@ -258528,6 +258528,81 @@ var init_HistorySqliteStore = __esm({
           });
         })();
       }
+      /**
+       * v3.4.1: append only the NEW messages for a session instead of rewriting
+       * the whole session. saveUiSessions() deletes every row and re-inserts the
+       * entire message list — on a long session that is a large synchronous
+       * better-sqlite3 transaction on the main event loop, which is the
+       * spinning-wheel freeze. This method appends from a given position in one
+       * small transaction, so a debounced flush costs O(new messages), not
+       * O(all messages).
+       *
+       * Returns the number of rows appended.
+       */
+      appendUiSessionMessages(sessionId, messages, fromPosition, summary) {
+        if (messages.length === 0 || fromPosition >= messages.length) {
+          return 0;
+        }
+        const upsertSession = this.db.prepare(
+          `INSERT INTO ui_sessions (
+         id, title, updated_at, messages_count, last_message_preview
+       ) VALUES (
+         @id, @title, @updatedAt, @messagesCount, @lastMessagePreview
+       )
+       ON CONFLICT(id) DO UPDATE SET
+         title = excluded.title,
+         updated_at = excluded.updated_at,
+         messages_count = excluded.messages_count,
+         last_message_preview = excluded.last_message_preview`
+        );
+        const insertMessage = this.db.prepare(
+          `INSERT INTO ui_session_messages (
+         session_id, position, ui_message_id, backend_message_id, role, message_type, content, metadata_json, timestamp, streaming
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        );
+        const slice = messages.slice(fromPosition);
+        this.db.transaction(() => {
+          if (summary) {
+            upsertSession.run({
+              id: sessionId,
+              title: summary.title,
+              updatedAt: summary.updatedAt,
+              messagesCount: summary.messagesCount,
+              lastMessagePreview: summary.lastMessagePreview
+            });
+          } else {
+            const existing = this.db.prepare("SELECT title, updated_at FROM ui_sessions WHERE id = ?").get(sessionId);
+            upsertSession.run({
+              id: sessionId,
+              title: existing?.title ?? "New Chat",
+              updatedAt: Date.now(),
+              messagesCount: (existing ? 0 : 0) + fromPosition + slice.length,
+              lastMessagePreview: slice[slice.length - 1]?.content?.slice(0, 200) ?? ""
+            });
+          }
+          for (let i = 0; i < slice.length; i++) {
+            const message = slice[i];
+            insertMessage.run(
+              sessionId,
+              fromPosition + i,
+              message.id,
+              message.backendMessageId ?? null,
+              message.role,
+              message.type,
+              message.content,
+              message.metadata ? JSON.stringify(message.metadata) : null,
+              message.timestamp,
+              message.streaming ? 1 : 0
+            );
+          }
+        })();
+        return slice.length;
+      }
+      /** v3.4.1: how many messages are already persisted for a session. */
+      countUiSessionMessages(sessionId) {
+        const row = this.db.prepare("SELECT COUNT(*) AS n FROM ui_session_messages WHERE session_id = ?").get(sessionId);
+        return row?.n ?? 0;
+      }
       deleteUiSessions(sessionIds) {
         const ids = Array.from(
           new Set(sessionIds.filter((id) => id.trim().length > 0))
@@ -350712,12 +350787,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 +354942,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 +369534,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 +369593,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 +370243,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 +370283,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,
@@ -373372,16 +373479,84 @@ function buildUiSessionSummary(session) {
 }
 
 // ../../packages/backend/src/services/UIHistoryService.ts
-var UIHistoryService = class {
+var UIHistoryService = class _UIHistoryService {
   store;
   sessionsCache = {};
   sessionSummaryCache = {};
   dirtySessions = /* @__PURE__ */ new Set();
+  /**
+   * v3.4.1: debounced auto-flush. Previously recordEvent() marked a session
+   * dirty but NEVER flushed — messages reached SQLite only on rename /
+   * rollback / branch or a graceful app close. Kill the process mid-run
+   * (freeze, crash, force-quit) and every message since the last flush was
+   * lost. That is the "work done, no record" bug.
+   *
+   * Now: flush within FLUSH_DEBOUNCE_MS of the last event, plus a synchronous
+   * flush on beforeExit / SIGINT / SIGTERM.
+   */
+  flushTimer = null;
+  shutdownHooksInstalled = false;
+  /** v3.4.1: messages already written to SQLite per session, so flush()
+   *  appends only the new ones instead of rewriting the whole session. */
+  persistedMessageCount = /* @__PURE__ */ new Map();
+  /** Flush debounce window — short enough to survive a crash, long enough
+   *  to batch a streaming burst into one write. */
+  static FLUSH_DEBOUNCE_MS = 1500;
   constructor(options) {
     this.store = options?.store || new HistorySqliteStore();
     this.sessionSummaryCache = this.buildSessionSummaryCache(
       this.store.listUiSessionSummaries()
     );
+    this.installShutdownHooks();
+  }
+  installShutdownHooks() {
+    if (this.shutdownHooksInstalled) return;
+    this.shutdownHooksInstalled = true;
+    const flushNow = () => {
+      try {
+        this.flush();
+      } catch {
+      }
+    };
+    process.once("beforeExit", flushNow);
+    for (const sig of ["SIGINT", "SIGTERM"]) {
+      if (!_UIHistoryService.activeFlushOnSignal.has(sig)) {
+        _UIHistoryService.activeFlushOnSignal.add(sig);
+        const hadListeners = process.listenerCount(sig) > 0;
+        process.once(sig, () => {
+          for (const svc of _UIHistoryService.instances) {
+            try {
+              svc.flush();
+            } catch {
+            }
+          }
+          _UIHistoryService.activeFlushOnSignal.delete(sig);
+          if (!hadListeners) {
+            process.kill(process.pid, sig);
+          }
+        });
+      }
+    }
+    _UIHistoryService.instances.add(this);
+  }
+  /** Live instances — the shared signal handler flushes all of them. */
+  static instances = /* @__PURE__ */ new Set();
+  static activeFlushOnSignal = /* @__PURE__ */ new Set();
+  scheduleFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      try {
+        this.flush();
+      } catch (error40) {
+        console.error("[UIHistory] auto-flush failed:", error40);
+      }
+    }, _UIHistoryService.FLUSH_DEBOUNCE_MS);
+    if (typeof this.flushTimer.unref === "function") {
+      this.flushTimer.unref();
+    }
   }
   buildSessionSummaryCache(summaries) {
     const cache2 = {};
@@ -373401,6 +373576,9 @@ var UIHistoryService = class {
     }
     const sanitized = sanitizeUiSession(loaded);
     this.sessionsCache[sessionId] = sanitized;
+    if (!this.persistedMessageCount.has(sessionId)) {
+      this.persistedMessageCount.set(sessionId, sanitized.messages.length);
+    }
     this.syncSessionSummary(sessionId);
     return sanitized;
   }
@@ -373427,6 +373605,7 @@ var UIHistoryService = class {
     const actions = this.processEvent(session, event, sessionId);
     this.syncSessionSummary(sessionId);
     this.dirtySessions.add(sessionId);
+    this.scheduleFlush();
     return actions;
   }
   flush(sessionId) {
@@ -373435,6 +373614,7 @@ var UIHistoryService = class {
       return;
     }
     const entries = [];
+    const appendFrom = {};
     sessionIds.forEach((id) => {
       const session = this.sessionsCache[id];
       if (!session) {
@@ -373446,9 +373626,34 @@ var UIHistoryService = class {
       const summary = buildUiSessionSummary(sanitized);
       this.sessionSummaryCache[id] = summary;
       entries.push({ session: sanitized, summary });
+      const already = this.persistedMessageCount.get(id);
+      appendFrom[id] = typeof already === "number" && already <= sanitized.messages.length ? already : 0;
     });
     if (entries.length > 0) {
-      this.store.saveUiSessions(entries);
+      let usedIncremental = false;
+      try {
+        let appended = 0;
+        for (const { session, summary } of entries) {
+          const from = appendFrom[session.id] ?? 0;
+          const n2 = this.store.appendUiSessionMessages(
+            session.id,
+            session.messages,
+            from,
+            summary
+          );
+          appended += n2;
+          this.persistedMessageCount.set(session.id, session.messages.length);
+        }
+        usedIncremental = true;
+      } catch {
+        usedIncremental = false;
+      }
+      if (!usedIncremental) {
+        this.store.saveUiSessions(entries);
+        entries.forEach(
+          ({ session }) => this.persistedMessageCount.set(session.id, session.messages.length)
+        );
+      }
     }
     sessionIds.forEach((id) => this.dirtySessions.delete(id));
   }
@@ -373961,6 +374166,7 @@ Error: ${event.message}` : ""),
       delete this.sessionsCache[id];
       delete this.sessionSummaryCache[id];
       this.dirtySessions.delete(id);
+      this.persistedMessageCount.delete(id);
     });
     this.store.deleteUiSessions(ids);
   }
@@ -373999,6 +374205,7 @@ Error: ${event.message}` : ""),
     );
     this.syncSessionSummary(sessionId);
     this.dirtySessions.add(sessionId);
+    this.persistedMessageCount.delete(sessionId);
     this.flush(sessionId);
     return removedCount;
   }
@@ -376649,6 +376856,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 +392793,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 +398249,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 +398921,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.9",
+  "version": "3.4.1",
   "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",