pygpt-net 2.6.59__py3-none-any.whl → 2.6.60__py3-none-any.whl

pygpt_net/tools/agent_builder/tool.py

@@ -6,9 +6,10 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.19 00:00:00                  #
+# Updated Date: 2025.09.24 00:00:00                  #
 # ================================================== #
 
+import copy
 from datetime import datetime
 from typing import Dict
 
@@ -18,21 +19,26 @@ from PySide6.QtGui import QAction, QIcon
 from pygpt_net.tools.base import BaseTool
 from pygpt_net.utils import trans
 
+from pygpt_net.core.node_editor.types import (
+    NodeTypeRegistry,
+    PropertySpec,
+    NodeTypeSpec
+)
+
 from .ui.dialogs import Builder
 
+
 class AgentBuilder(BaseTool):
     def __init__(self, *args, **kwargs):
-        """
-        Agent builder (nodes editor)
-
-        :param window: Window instance
-        """
         super(AgentBuilder, self).__init__(*args, **kwargs)
         self.id = "agent_builder"
         self.opened = False
         self.dialog = None  # dialog
         self.initialized = False
         self.current_agent = None  # current agent ID
+        # Reentrancy/teardown guards
+        self._restoring = False    # True while restore/load is in progress
+        self._closing = False      # True while dialog is being closed
 
     def setup(self):
         """Setup controller"""
@@ -42,17 +48,41 @@ class AgentBuilder(BaseTool):
         """Update"""
         pass
 
-    def save(self):
+    def save(self, force: bool = False):
         """Save layout to file"""
+        # Never save during restore or teardown
+        if not self.opened or self._closing or self._restoring:
+            if not force:
+                return
         if "agent.builder" not in self.window.ui.editor:
             return
+
+        builder = self.window.ui.editor["agent.builder"]
+        # Ensure the editor is alive (not closing)
+        if not getattr(builder, "_alive", True) or getattr(builder, "_closing", False):
+            return
+
+        data = builder.save_layout()
+        if not isinstance(data, dict):
+            return  # skip invalid snapshots
+
+        schema_list = builder.export_schema(as_list=True)
+        try:
+            # Deep copy for safety (JSON-only types expected)
+            layout = copy.deepcopy(data)
+            schema = copy.deepcopy(schema_list)
+        except Exception:
+            # As a fallback, store raw references (still pure dict/list)
+            layout = data
+            schema = schema_list
+
         custom = self.window.core.agents.custom
-        layout = self.window.ui.editor["agent.builder"].save_layout()
         custom.update_layout(layout)
         if self.current_agent:
-            custom.update_agent_layout(self.current_agent, layout)
+            custom.update_agent(self.current_agent, layout, schema)
         custom.save()
         self.window.update_status(f"Saved at: {datetime.now().strftime('%H:%M:%S')}")
+        self.update_presets()
 
     def load(self):
         """Load layout from file"""
@@ -60,11 +90,10 @@ class AgentBuilder(BaseTool):
 
     def open(self):
         """Open dialog"""
-        if not self.initialized:
-            self.dialog = Builder(self.window, tool=self)
-            self.dialog.setup()
-            self.restore()
-            self.initialized = True
+        self.dialog = Builder(self.window, tool=self)
+        self.dialog.setup()
+        # Defer restore to allow previous deleteLater() to be processed
+        QtCore.QTimer.singleShot(0, self.restore)
         self.window.ui.dialogs.open('agent.builder', width=900, height=600)
         self.opened = True
         self.update()
@@ -81,26 +110,33 @@ class AgentBuilder(BaseTool):
         else:
             self.open()
 
-    def store_current(self):
+    def store_current(self, force: bool = False):
         """Store current to file"""
-        self.save()
+        if self.opened and not self._restoring and (not self._closing or force):
+            self.save(force=force)
 
     def restore(self):
         """Restore layout and agents from file"""
-        layout = self.window.core.agents.custom.get_layout()
-        if layout:
-            data = layout.data
-            if data:
-                self.window.ui.editor["agent.builder"].load_layout(data)
-                self.window.update_status(f"Loaded layout at: {datetime.now().strftime('%H:%M:%S')}")
+        if self._closing:
+            return
+        self._restoring = True
+        try:
+            layout = self.window.core.agents.custom.get_layout()
+            if layout and "agent.builder" in self.window.ui.editor:
+                data = layout.data
+                if data:
+                    self.window.ui.editor["agent.builder"].load_layout(data)
+                    self.window.update_status(f"Loaded layout at: {datetime.now().strftime('%H:%M:%S')}")
 
-        self.update_list()
+            self.update_list()
 
-        # select first agent on list
-        agents = self.window.core.agents.custom.get_agents()
-        if agents and len(agents) > 0:
-            first_agent_id = list(agents.keys())[0]
-            self.edit_agent(first_agent_id)
+            # select first agent on list
+            agents = self.window.core.agents.custom.get_agents()
+            if agents and len(agents) > 0:
+                first_agent_id = list(agents.keys())[0]
+                self.edit_agent(first_agent_id)
+        finally:
+            self._restoring = False
 
     def show_hide(self, show: bool = True):
         """
@@ -114,13 +150,18 @@ class AgentBuilder(BaseTool):
             self.close()
 
     def on_close(self):
-        """On window close"""
-        self.opened = False
-        self.update()
+        """On dialog window close (before destroy)"""
+        self._closing = True
+        try:
+            self.store_current(force=True)
+        finally:
+            self.opened = False
+            self._closing = False
 
     def on_exit(self):
-        """On exit"""
-        self.store_current()
+        """On app exit"""
+        if self.opened:
+            self.on_close()
 
     def clear(self, force: bool = False):
         """
@@ -135,24 +176,33 @@ class AgentBuilder(BaseTool):
                 msg=trans('agent.builder.confirm.clear.msg'),
             )
             return
-        if self.window.ui.editor["agent.builder"].clear(ask_user=False):
-            self.save()
+        if "agent.builder" in self.window.ui.editor:
+            if self.window.ui.editor["agent.builder"].clear(ask_user=False):
+                self.save()
 
     def add_agent(self, name: str = None):
         """Add new agent"""
         if name is None:
-            self.window.ui.dialog['create'].id = 'agent.builder.agent'
-            self.window.ui.dialog['create'].input.setText("")
-            self.window.ui.dialog['create'].current = ""
-            self.window.ui.dialog['create'].show()
-            self.window.ui.dialog['create'].input.setFocus()
+            dialog = self.window.ui.dialog['create']
+            dialog.id = 'agent.builder.agent'
+            dialog.input.setText("")
+            dialog.current = ""
+            dialog.show()
+            dialog.input.setFocus()
             return
+
+        if self.current_agent:
+            self.save()  # save current before creating new
+
+        self.current_agent = None # prevent overwriting current agent
         uuid = self.window.core.agents.custom.new_agent(name)
         if uuid:
             self.update_list()
-            self.window.ui.editor["agent.builder"].clear(ask_user=False)
+            if "agent.builder" in self.window.ui.editor:
+                self.window.ui.editor["agent.builder"].clear(ask_user=False)
             self.window.ui.dialogs.close('create')
             self.edit_agent(uuid)
+            self.update_presets()
 
     def rename_agent(self, agent_id: str, name: str = None):
         """
@@ -167,17 +217,19 @@ class AgentBuilder(BaseTool):
             return
         current_name = agent.name
         if name is None:
-            self.window.ui.dialog['rename'].id = 'agent.builder.agent'
-            self.window.ui.dialog['rename'].input.setText(current_name)
-            self.window.ui.dialog['rename'].current =agent_id
-            self.window.ui.dialog['rename'].show()
-            self.window.ui.dialog['rename'].input.setFocus()
+            dialog = self.window.ui.dialog['rename']
+            dialog.id = 'agent.builder.agent'
+            dialog.input.setText(current_name)
+            dialog.current =agent_id
+            dialog.show()
+            dialog.input.setFocus()
             return
         if agent:
             agent.name = name
             self.window.core.agents.custom.save()
             self.update_list()
             self.window.ui.dialogs.close('rename')
+            self.update_presets()
 
     def edit_agent(self, agent_id: str):
         """
@@ -185,16 +237,36 @@ class AgentBuilder(BaseTool):
 
         :param agent_id: agent ID
         """
-        self.save()
+        # Save current agent only when switching and UI is stable
+        if (
+            self.current_agent
+            and self.current_agent != agent_id
+            and self.opened
+            and not self._restoring
+            and not self._closing
+            and "agent.builder" in self.window.ui.editor
+        ):
+            builder = self.window.ui.editor["agent.builder"]
+            if getattr(builder, "_alive", True) and not getattr(builder, "_closing", False):
+                self.save()
+
         self.current_agent = agent_id
+
+        if "agent.builder" not in self.window.ui.editor:
+            return
+
         agent = self.window.core.agents.custom.get_agent(agent_id)
         if agent:
+            editor = self.window.ui.editor["agent.builder"]
             layout = agent.layout
             if layout:
-                self.window.ui.editor["agent.builder"].load_layout(layout)
+                editor.load_layout(layout)
             else:
-                self.window.ui.editor["agent.builder"].clear(ask_user=False)
-            self.select_on_list(agent_id)
+                editor.clear(ask_user=False)
+
+            # Select on list only when the list exists (dialog open)
+            if "agent.builder.list" in self.window.ui.nodes:
+                self.select_on_list(agent_id)
 
     def duplicate_agent(self, agent_id: str):
         """
@@ -224,12 +296,31 @@ class AgentBuilder(BaseTool):
             return
         self.window.core.agents.custom.delete_agent(agent_id)
         self.update_list()
+
+        # if deleted current, clear editor
         if self.current_agent == agent_id:
             self.current_agent = None
-            self.window.ui.editor["agent.builder"].clear(ask_user=False)
+            if "agent.builder" in self.window.ui.editor:
+                self.window.ui.editor["agent.builder"].clear(ask_user=False)
+
+            # select current selected on list if any after deletion (only if UI is open)
+            if self.opened and "agent.builder.list" in self.window.ui.nodes:
+                agents = self.window.core.agents.custom.get_agents()
+                if agents and len(agents) > 0:
+                    idx = self.window.ui.nodes["agent.builder.list"].list.currentIndex()
+                    if idx.isValid():
+                        next_id = idx.data(QtCore.Qt.UserRole)
+                        self.edit_agent(next_id)
+
+    def update_presets(self):
+        """Update presets in the tools"""
+        self.window.controller.presets.editor.reload_all(all=True)
 
     def update_list(self):
         """Update agents list"""
+        # Guard: dialog may not be open; do nothing if widget is not present
+        if "agent.builder.list" not in self.window.ui.nodes:
+            return
         data = self.window.core.agents.custom.get_agents()
         self.window.ui.nodes["agent.builder.list"].update_list(data)
 
@@ -239,13 +330,16 @@ class AgentBuilder(BaseTool):
 
         :param agent_id: agent ID
         """
+        if "agent.builder.list" not in self.window.ui.nodes:
+            return
+
         nodes = self.window.ui.nodes
         models = self.window.ui.models
 
         agents_list = nodes["agent.builder.list"].list
         model = models.get("agent.builder.list")
 
-        if model is None:
+        if model is None or agents_list is None:
             return
         for row in range(model.rowCount()):
             idx = model.index(row, 0)
@@ -279,6 +373,77 @@ class AgentBuilder(BaseTool):
         """Setup dialogs (static)"""
         pass
 
+    def get_registry(self) -> NodeTypeRegistry:
+        """
+        Get node type registry
+
+        :return: NodeTypeRegistry
+        """
+        registry = NodeTypeRegistry(empty=True)
+        # Tip: to allow multiple connections to an input or output, set allowed_inputs/allowed_outputs to -1.
+
+        # Start
+        registry.register(NodeTypeSpec(
+            type_name="Flow/Start",
+            title="Start",
+            base_id="start",
+            export_kind="start",
+            bg_color="#2D5A27",
+            properties=[
+                PropertySpec(id="output", type="flow", name="Output", editable=False, allowed_inputs=0,
+                             allowed_outputs=1),
+                PropertySpec(id="memory", type="memory", name="Memory", editable=False, allowed_inputs=0,
+                             allowed_outputs=-1),
+                # base_id will be auto-injected as read-only property at creation
+            ],
+        ))
+        # Agent
+        registry.register(NodeTypeSpec(
+            type_name="Flow/Agent",
+            title="Agent",
+            base_id="agent",
+            export_kind="agent",
+            bg_color="#304A6E",
+            properties=[
+                PropertySpec(id="name", type="str", name="Name", editable=True, value=""),
+                PropertySpec(id="instruction", type="text", name="Instruction", editable=True, value=""),
+                PropertySpec(id="remote_tools", type="bool", name="Remote tools", editable=True, value=True),
+                PropertySpec(id="local_tools", type="bool", name="Local tools", editable=True, value=True),
+                PropertySpec(id="input", type="flow", name="Input", editable=False, allowed_inputs=-1,
+                             allowed_outputs=0),
+                PropertySpec(id="output", type="flow", name="Output", editable=False, allowed_inputs=0,
+                             allowed_outputs=-1),
+                PropertySpec(id="memory", type="memory", name="Memory", editable=False, allowed_inputs=0,
+                             allowed_outputs=1),
+            ],
+        ))
+        # Memory
+        registry.register(NodeTypeSpec(
+            type_name="Flow/Memory",
+            title="Memory (Context)",
+            base_id="mem",
+            export_kind="memory",
+            bg_color="#593E78",
+            properties=[
+                PropertySpec(id="name", type="str", name="Name", editable=True, value=""),
+                PropertySpec(id="input", type="memory", name="Agent", editable=False, allowed_inputs=-1,
+                             allowed_outputs=0),
+            ],
+        ))
+        # End
+        registry.register(NodeTypeSpec(
+            type_name="Flow/End",
+            title="End",
+            base_id="end",
+            export_kind="end",
+            bg_color="#6B2E2E",
+            properties=[
+                PropertySpec(id="input", type="flow", name="Input", editable=False, allowed_inputs=-1,
+                             allowed_outputs=0),
+            ],
+        ))
+        return registry
+
     def get_lang_mappings(self) -> Dict[str, Dict]:
         """
         Get language mappings

pygpt_net/tools/agent_builder/ui/dialogs.py

@@ -6,18 +6,20 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.19 00:00:00                  #
+# Updated Date: 2025.09.24 00:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, QEvent
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QVBoxLayout, QMenuBar, QSplitter
+from PySide6.QtWidgets import QVBoxLayout, QMenuBar, QSplitter, QSizePolicy
 
-from pygpt_net.tools.agent_builder.ui.list import AgentsWidget
-from pygpt_net.ui.widget.builder.editor import NodeEditor
+from pygpt_net.ui.widget.element.labels import HelpLabel
+from pygpt_net.ui.widget.node_editor.editor import NodeEditor
 from pygpt_net.ui.widget.dialog.base import BaseDialog
 from pygpt_net.utils import trans
 
+from .list import AgentsWidget
+
 
 class Builder:
 
@@ -34,12 +36,12 @@ class Builder:
         self.actions = {}
 
     def setup_menu(self, parent=None) -> QMenuBar:
-        """Setup audio agent_builder dialog menu"""
+        """Setup agent_builder dialog menu"""
         self.menu_bar = QMenuBar(parent)
         self.file_menu = self.menu_bar.addMenu(trans("menu.file"))
         t = self.tool
 
-        self.actions["open"] = QAction(QIcon(":/icons/folder.svg"), trans("action.open"), self.menu_bar)
+        self.actions["open"] = QAction(QIcon(":/icons/reload.svg"), "Reload", self.menu_bar)
         self.actions["open"].triggered.connect(lambda checked=False, t=t: t.load())
 
         self.actions["save"] = QAction(QIcon(":/icons/save.svg"), trans("action.save"), self.menu_bar)
@@ -55,36 +57,44 @@ class Builder:
 
     def setup(self):
         """Setup agent_builder dialog"""
+        # Ensure previous deferred deletions are flushed before building a new editor instance
+        try:
+            from PySide6.QtWidgets import QApplication
+            QApplication.sendPostedEvents(None, QEvent.DeferredDelete)
+            QApplication.processEvents()
+        except Exception:
+            pass
+
         id = 'agent.builder'
         u = self.window.ui
 
         u.dialog['agent.builder'] = BuilderDialog(self.window)
         dlg = u.dialog['agent.builder']
 
-        editor = NodeEditor(dlg)  # parent == dialog
+        registry = self.tool.get_registry()  # node types
+        editor = NodeEditor(
+            parent=dlg,
+            registry=registry
+        )  # parent == dialog
+
         editor.setStyleSheet("""
             NodeEditor {
                 qproperty-gridBackColor: #242629;
                 qproperty-gridPenColor:  #3b3f46;
-    
+
                 qproperty-nodeBackgroundColor: #2d2f34;
                 qproperty-nodeBorderColor:     #4b4f57;
                 qproperty-nodeSelectionColor:  #ff9900;
                 qproperty-nodeTitleColor:      #3a3d44;
-    
+
                 qproperty-portInputColor:      #66b2ff;
                 qproperty-portOutputColor:     #70e070;
                 qproperty-portConnectedColor:  #ffd166;
-    
+
                 qproperty-edgeColor:           #c0c0c0;
                 qproperty-edgeSelectedColor:   #ff8a5c;
             }
             """)
-
-        # Demo: add a couple of nodes
-        #editor.add_node("Value/Float", QPointF(100, 120))
-        #editor.add_node("Value/Float", QPointF(100, 240))
-        #editor.add_node("Math/Add", QPointF(420, 180))
         editor.on_clear = self.tool.clear
 
         u.editor[id] = editor
@@ -92,7 +102,7 @@ class Builder:
         layout = QVBoxLayout()
         layout.setMenuBar(self.setup_menu(dlg))
 
-        agents_list = AgentsWidget(self.window, tool=self.tool)
+        agents_list = AgentsWidget(self.window, tool=self.tool, parent=dlg)
         list_widget = agents_list.setup()
         list_widget.setFixedWidth(250)
         center_splitter = QSplitter(Qt.Horizontal)
@@ -101,14 +111,30 @@ class Builder:
         center_splitter.setStretchFactor(0, 1)
         center_splitter.setStretchFactor(1, 8)
         layout.addWidget(center_splitter)
-
+        # Make the splitter take all extra vertical space so the legend stays compact at the bottom
+        layout.setStretch(0, 1)
+
+        # Bottom legend as a compact, centered help label
+        legend_label = HelpLabel(
+            "Right-click: add node / undo / redo • Middle-click: pan view • Ctrl + Mouse wheel: zoom • "
+            "Left-click a port: create connection • Ctrl + Left-click a port: rewire or detach • Right-click or DEL a node/connection: remove"
+        )
+        legend_label.setAlignment(Qt.AlignCenter)
+        legend_label.setWordWrap(True)
+        legend_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
+        legend_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
+
+        layout.addWidget(legend_label)
+
+        u.nodes["agent.builder.splitter"] = center_splitter
         u.nodes["agent.builder.list"] = agents_list
+        u.nodes["agent.builder.legend"] = legend_label
 
         dlg.setLayout(layout)
         dlg.setWindowTitle(trans("agent.builder.title"))
 
     def clear(self):
-        """Clear transcribe dialog"""
+        """Clear dialog"""
         pass
 
 
@@ -123,6 +149,7 @@ class BuilderDialog(BaseDialog):
         super(BuilderDialog, self).__init__(window, id)
         self.window = window
         self.id = id  # id
+        self._cleaned = False
 
     def closeEvent(self, event):
         """
@@ -140,13 +167,81 @@ class BuilderDialog(BaseDialog):
         :param event: key press event
         """
         if event.key() == Qt.Key_Escape:
-            self.cleanup()
             self.close()
         else:
             super(BuilderDialog, self).keyPressEvent(event)
 
     def cleanup(self):
-        """
-        Cleanup on close
-        """
-        self.window.tools.get("agent_builder").on_close()
+        """Cleanup on dialog close"""
+        if self._cleaned:
+            return
+        self._cleaned = True
+
+        tool = self.window.tools.get("agent_builder")
+        if tool:
+            try:
+                tool.on_close()  # store current state (layout, nodes positions, etc.)
+            except Exception:
+                pass
+
+        u = self.window.ui
+
+        try:
+            u.nodes["agent.builder.list"].cleanup()
+        except Exception as e:
+            print("Agents list close failed:", e)
+
+        splitter = u.nodes.get("agent.builder.splitter")
+        editor = u.editor.pop('agent.builder', None)
+
+        # Detach editor from splitter before closing/deleting it to avoid dangling pointers in QSplitter
+        try:
+            if splitter is not None and editor is not None:
+                # Ensure the editor actually belongs to this splitter
+                idx = splitter.indexOf(editor) if editor.parent() is splitter else -1
+                if idx != -1:
+                    # Create the replacement without a parent; QSplitter will adopt it.
+                    from PySide6.QtWidgets import QWidget as _QW
+                    placeholder = _QW()
+                    splitter.replaceWidget(idx, placeholder)
+        except Exception as e:
+            print("Splitter detach failed:", e)
+
+        if editor is not None:
+            try:
+                editor.setStyleSheet("")
+            except Exception:
+                pass
+            try:
+                editor.close()
+            except Exception as e:
+                print("NodeEditor close failed:", e)
+            try:
+                editor.setParent(None)
+                editor.deleteLater()
+            except Exception:
+                pass
+
+        # Dispose legend label safely
+        legend = u.nodes.pop("agent.builder.legend", None)
+        if legend is not None:
+            try:
+                legend.setParent(None)
+                legend.deleteLater()
+            except Exception:
+                pass
+
+        # Drop splitter reference
+        try:
+            u.nodes.pop("agent.builder.splitter", None)
+        except Exception:
+            pass
+
+        # Ensure all deferred deletions are processed (do it a few rounds to be safe)
+        try:
+            from PySide6.QtWidgets import QApplication
+            for _ in range(3):
+                QApplication.sendPostedEvents(None, QEvent.DeferredDelete)
+                QApplication.processEvents()
+        except Exception:
+            pass