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

pygpt_net/core/agents/runners/llama_workflow.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 02:00:00                  #
+# Updated Date: 2025.09.26 17:00:00                  #
 # ================================================== #
 
 import re
@@ -18,6 +18,7 @@ from llama_index.core.agent.workflow import (
     ToolCallResult,
     AgentStream,
     AgentOutput,
+    # AgentInput,  # not needed currently
 )
 from workflows.errors import WorkflowCancelledByUser
 
@@ -38,6 +39,7 @@ class LlamaWorkflow(BaseRunner):
         """
         super(LlamaWorkflow, self).__init__(window)
         self.window = window
+        self.last_response_id = None
 
     async def run(
             self,
@@ -177,12 +179,13 @@ class LlamaWorkflow(BaseRunner):
 
         prev_output = ctx.live_output
         if prev_output:
-            prev_output = self.filter_output(prev_output)  # remove all <execute>...</execute>
+            prev_output = self.filter_output(prev_output)  # remove all [!exec]...[/!exec]
 
         response_ctx.set_agent_final_response(ctx.agent_final_response)  # always set to further use
         response_ctx.set_output(prev_output)  # append from stream
         response_ctx.extra["agent_output"] = True  # mark as output response
         response_ctx.extra["agent_finish"] = True  # mark as finished
+        response_ctx.set_agent_name(ctx.get_agent_name()) # store last agent name
 
         if "agent_input" in response_ctx.extra:
             del response_ctx.extra["agent_input"]  # remove agent input from extra
@@ -254,8 +257,10 @@ class LlamaWorkflow(BaseRunner):
         item_ctx.output = ""  # empty to prevent render
         item_ctx.stream = ""  # for stream
 
+        # Keep last known agent name to avoid redundant ctx updates.
+        last_agent_name: Optional[str] = None
+
         async for event in handler.stream_events():
-            print(event)
             if self.is_stopped():
                 # persist current output on stop
                 item_ctx.output = item_ctx.live_output
@@ -297,7 +302,24 @@ class LlamaWorkflow(BaseRunner):
                         begin=begin,
                         stream=True,
                     )
+                    # Propagate agent name early based on StepEvent meta, if available.
+                    try:
+                        meta = getattr(event, "meta", {}) or {}
+                        next_name = meta.get("agent_name")
+                        if next_name:
+                            last_agent_name = self._apply_agent_name_to_ctx(item_ctx, next_name, last_agent_name)
+                    except Exception:
+                        pass
+                # Optional: mark start of a new stream block
+                begin = True
             elif isinstance(event, AgentStream):
+                # Update agent name from event if present; fallback to header parsing.
+                name = getattr(event, "current_agent_name", None)
+                if not name:
+                    name = self._guess_agent_name_from_text(getattr(event, "delta", "") or "")
+                if name:
+                    last_agent_name = self._apply_agent_name_to_ctx(item_ctx, name, last_agent_name)
+
                 if verbose:
                     print(f"{event.delta}", end="", flush=True)
                 if event.delta:
@@ -307,6 +329,10 @@ class LlamaWorkflow(BaseRunner):
                         self.send_stream(item_ctx, signals, begin)  # send stream to webview
                     begin = False
             elif isinstance(event, AgentOutput):
+                # Ensure final agent name is applied as well.
+                name = getattr(event, "current_agent_name", None)
+                if name:
+                    last_agent_name = self._apply_agent_name_to_ctx(item_ctx, name, last_agent_name)
                 thought, answer = self.extract_final_response(str(event))
                 if answer:
                     item_ctx.set_agent_final_response(answer)
@@ -348,6 +374,40 @@ class LlamaWorkflow(BaseRunner):
         next_ctx.set_output("")
         next_ctx.partial = True
         next_ctx.extra["agent_output"] = True  # allow usage in history
-
+        next_ctx.set_agent_name(ctx.get_agent_name())  # propagate agent name
         self.send_response(next_ctx, signals, KernelEvent.APPEND_DATA)
-        return next_ctx
+
+        return next_ctx
+
+    # ===== helpers for agent name propagation =====
+
+    def _apply_agent_name_to_ctx(self, ctx: CtxItem, name: str, last_known: Optional[str]) -> str:
+        """
+        Apply agent name to your context, avoiding redundant updates.
+        Falls back to ctx.extra['agent_name'] if set_agent_name is unavailable.
+        """
+        if not name:
+            return last_known or ""
+        if last_known and last_known == name:
+            return last_known
+        try:
+            if hasattr(ctx, "set_agent_name") and callable(getattr(ctx, "set_agent_name")):
+                ctx.set_agent_name(name)
+            # Always mirror into extra for downstream consumers
+            ctx.extra["agent_name"] = name
+        except Exception:
+            ctx.extra["agent_name"] = name
+        return name
+
+    def _guess_agent_name_from_text(self, text: str) -> Optional[str]:
+        """
+        Try to infer agent name from header like '**Name**' which our workflow emits
+        before each agent block.
+        """
+        if not text:
+            return None
+        # Look for the first bold segment – keep it lenient
+        m = re.search(r"\*\*([^*]+?)\*\*", text)
+        if m:
+            return m.group(1).strip()
+        return None

pygpt_net/core/agents/runners/openai_workflow.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 03:00:00                  #
+# Updated Date: 2025.09.26 17:00:00                  #
 # ================================================== #
 
 from typing import Dict, Any, List, Optional
@@ -237,6 +237,7 @@ class OpenAIWorkflow(BaseRunner):
         response_ctx.set_agent_final_response(output)  # always set to further use
         response_ctx.extra["agent_output"] = True  # mark as output response
         response_ctx.extra["agent_finish"] = True  # mark as finished
+        response_ctx.set_agent_name(ctx.get_agent_name()) # store last agent name
         response_ctx.msg_id = response_id  # set response id for OpenAI
 
         if ctx.agent_final_response:  # only if not empty

pygpt_net/core/db/viewer.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 18:00:00                  #
+# Updated Date: 2025.09.26 03:00:00                  #
 # ================================================== #
 
 import json
@@ -154,14 +154,18 @@ class Viewer:
                 msg = f"[DB] Created DB backup: {backup_path}"
                 self.log(msg)
 
+        tables = self.database.get_tables()
+        primary_key = tables[data['table']]['primary_key']
+
         with self.database.get_db().begin() as conn:
             conn.execute(
-                text(f"DELETE FROM {data['table']} WHERE id = :row_id")
+                text(f"DELETE FROM {data['table']} WHERE {primary_key} = :row_id")
                 .bindparams(row_id=data['row_id'])
             )
             msg = f"[DB] Deleted row ID {data['row_id']} from table {data['table']}"
             self.log(msg)
-        self.database.window.ui.debug["db"].browser.update_table_view()
+        # Force refresh to invalidate caches and handle pagination edge cases
+        self.database.window.ui.debug["db"].browser.force_refresh()
 
     def update_row(self, data: Dict[str, Any]):
         """
@@ -207,7 +211,8 @@ class Viewer:
             )
             msg = f"[DB] Updated row ID {data['id']} in table {data['table']}"
             self.log(msg)
-        self.database.window.ui.debug["db"].browser.update_table_view()
+        # Force refresh to invalidate caches and handle pagination edge cases
+        self.database.window.ui.debug["db"].browser.force_refresh()
 
     def truncate_table(self, data: Dict[str, Any], reset: bool = False):
         """
@@ -230,7 +235,8 @@ class Viewer:
             else:
                 msg = f"[DB] Deleted all rows from table {data['table']}"
             self.log(msg)
-        self.database.window.ui.debug["db"].browser.update_table_view()
+        # Force refresh to invalidate caches and handle pagination edge cases
+        self.database.window.ui.debug["db"].browser.force_refresh()
 
     def log(self, msg: str):
         """

pygpt_net/core/node_editor/graph.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 00:00:00                  #
+# Updated Date: 2025.09.25 00:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -83,16 +83,24 @@ class NodeGraph(QObject):
         props: Dict[str, PropertyModel] = {}
         for ps in spec.properties:
             props[ps.id] = PropertyModel(
-                uuid=gen_uuid(), id=ps.id, type=ps.type, name=ps.name or ps.id,
-                editable=ps.editable, value=ps.value,
-                allowed_inputs=ps.allowed_inputs, allowed_outputs=ps.allowed_outputs,
-                options=ps.options
+                uuid=gen_uuid(),
+                id=ps.id,
+                type=ps.type,
+                name=ps.name or ps.id,
+                editable=ps.editable,
+                value=ps.value,
+                allowed_inputs=ps.allowed_inputs,
+                allowed_outputs=ps.allowed_outputs,
+                options=ps.options,
+                placeholder=getattr(ps, "placeholder", None),
+                description=getattr(ps, "description", None),
             )
         # Auto inject read-only 'base_id' property for visibility if base_id defined and not present
         if spec.base_id and "base_id" not in props:
             props["base_id"] = PropertyModel(
                 uuid=gen_uuid(), id="base_id", type="str", name="Base ID",
-                editable=False, value=base_id, allowed_inputs=0, allowed_outputs=0
+                editable=False, value=base_id, allowed_inputs=0, allowed_outputs=0,
+                placeholder=None, description="Internal base identifier (read-only)."
             )
 
         node = NodeModel(uuid=gen_uuid(), id=nid, name=name or spec.title or nid, type=type_name, properties=props)
@@ -195,7 +203,8 @@ class NodeGraph(QObject):
                 "type": n.type,
                 "id": n.id,
                 "name": n.name,
-                "values": {pid: p.value for pid, p in n.properties.items()},
+                # UI-only fields like HelpLabel are skipped
+                "values": {pid: p.value for pid, p in n.properties.items() if p.type != "HelpLabel"},
             }
         conns_out = [{"src": [c.src_node, c.src_prop], "dst": [c.dst_node, c.dst_prop]}
                      for c in self.connections.values()]
@@ -226,8 +235,8 @@ class NodeGraph(QObject):
                         "out": list(outgoing.get((n.uuid, pid), [])),
                     }
                 else:
-                    # Skip internal helper fields if needed
-                    if pid == "base_id":
+                    # Skip internal/helper and UI-only fields
+                    if pid == "base_id" or prop.type == "HelpLabel":
                         continue
                     slots[pid] = prop.value
             result.append({

pygpt_net/core/node_editor/models.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 00:00:00                  #
+# Updated Date: 2025.09.25 00:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -22,13 +22,16 @@ from .utils import gen_uuid
 class PropertyModel:
     uuid: str
     id: str
-    type: str  # "slot", "str", "int", "float", "bool", "combo", "text"
+    type: str  # "slot", "str", "int", "float", "bool", "combo", "text", "HelpLabel"
     name: str
     editable: bool = True
     value: Any = None
     allowed_inputs: int = 0   # 0 none, -1 unlimited, >0 limit
     allowed_outputs: int = 0  # 0 none, -1 unlimited, >0 limit
     options: Optional[List[str]] = None  # for combo
+    # UI helpers
+    placeholder: Optional[str] = None
+    description: Optional[str] = None
 
     def to_dict(self) -> dict:
         return {
@@ -41,6 +44,8 @@ class PropertyModel:
             "allowed_inputs": self.allowed_inputs,
             "allowed_outputs": self.allowed_outputs,
             "options": self.options or [],
+            "placeholder": self.placeholder,
+            "description": self.description,
         }
 
     @staticmethod
@@ -55,6 +60,8 @@ class PropertyModel:
             allowed_inputs=d.get("allowed_inputs", 0),
             allowed_outputs=d.get("allowed_outputs", 0),
             options=d.get("options") or None,
+            placeholder=d.get("placeholder"),
+            description=d.get("description"),
         )
 
 

pygpt_net/core/node_editor/types.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 00:00:00                  #
+# Updated Date: 2025.09.26 12:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -26,17 +26,22 @@ class PropertySpec:
     allowed_inputs: int = 0
     allowed_outputs: int = 0
     options: Optional[List[str]] = None
+    placeholder: Optional[str] = None      # hint text for text editors
+    description: Optional[str] = None      # tooltip/help text shown in UI
 
 
 @dataclass
 class NodeTypeSpec:
     type_name: str
     title: Optional[str] = None
+    # UI-only human-readable label used for menus; never persisted nor used as an identifier
+    display_name: Optional[str] = None
     properties: List[PropertySpec] = field(default_factory=list)
     # Below are optional extensions for agent-flow needs:
     base_id: Optional[str] = None        # base prefix for friendly ids, e.g. "agent"
     export_kind: Optional[str] = None    # short kind for export, e.g. "agent", "start"
     bg_color: Optional[str] = None       # optional per-type background color (CSS/hex)
+    max_num: Optional[int] = None        # optional per-layout cap; None or <=0 means unlimited
 
 class NodeTypeRegistry:
     """Registry for node type specifications. Extend/override in subclasses."""
@@ -54,6 +59,15 @@ class NodeTypeRegistry:
     def get(self, type_name: str) -> Optional[NodeTypeSpec]:
         return self._types.get(type_name)
 
+    def display_name(self, type_name: str) -> str:
+        """Return UI label for a type: spec.display_name if non-empty, otherwise type_name."""
+        spec = self.get(type_name)
+        if spec:
+            dn = getattr(spec, "display_name", None)
+            if isinstance(dn, str) and dn.strip():
+                return dn
+        return type_name
+
     def _install_default_types(self):
         # Example/basic nodes kept intact
         self.register(NodeTypeSpec(

pygpt_net/core/presets/presets.py

@@ -6,12 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.28 09:00:00                  #
+# Updated Date: 2025.09.26 03:00:00                  #
 # ================================================== #
 
 import copy
 import uuid
-from typing import Optional, Tuple, Dict
+from collections import OrderedDict
+from typing import Optional, Tuple, Dict, List
 
 from packaging.version import Version
 from pygpt_net.core.types import (
@@ -165,10 +166,6 @@ class Presets:
             return MODE_COMPLETION
         if preset.img:
             return MODE_IMAGE
-        # if preset.vision:
-            # return MODE_VISION
-        # if preset.langchain:
-            # return MODE_LANGCHAIN
         if preset.assistant:
             return MODE_ASSISTANT
         if preset.llama_index:
@@ -214,12 +211,10 @@ class Presets:
         attr = self._MODE_TO_ATTR.get(mode)
         if not attr:
             return
-        i = 0
-        for key, item in self.items.items():
-            if getattr(item, attr, False):
-                if i == idx:
-                    return key
-                i += 1
+        ids = list(self.get_by_mode(mode).keys())
+        if idx < 0 or idx >= len(ids):
+            return
+        return ids[idx]
 
     def get_by_id(self, mode: str, id: str) -> Optional[PresetItem]:
         """
@@ -265,7 +260,19 @@ class Presets:
         attr = self._MODE_TO_ATTR.get(mode)
         if not attr:
             return {}
-        return {id: item for id, item in self.items.items() if getattr(item, attr, False)}
+        data = {id: item for id, item in self.items.items() if getattr(item, attr, False)}
+        if not self._dnd_enabled():
+            return data
+        ordered_ids = self._ordered_ids_for_mode(mode)
+        out = OrderedDict()
+        for pid in ordered_ids:
+            itm = data.get(pid)
+            if itm is not None:
+                out[pid] = itm
+        for pid, itm in data.items():
+            if pid not in out:
+                out[pid] = itm
+        return out
 
     def get_idx_by_id(self, mode: str, id: str) -> int:
         """
@@ -275,16 +282,13 @@ class Presets:
         :param id: preset id
         :return: preset idx
         """
-        attr = self._MODE_TO_ATTR.get(mode)
-        if not attr:
+        if id is None:
+            return 0
+        ids = list(self.get_by_mode(mode).keys())
+        try:
+            return ids.index(id)
+        except ValueError:
             return 0
-        i = 0
-        for key, item in self.items.items():
-            if getattr(item, attr, False):
-                if key == id:
-                    return i
-                i += 1
-        return 0
 
     def get_default(self, mode: str) -> Optional[str]:
         """
@@ -293,12 +297,9 @@ class Presets:
         :param mode: mode name
         :return: default prompt name
         """
-        attr = self._MODE_TO_ATTR.get(mode)
-        if not attr:
-            return None
-        for key, item in self.items.items():
-            if getattr(item, attr, False):
-                return key
+        data = self.get_by_mode(mode)
+        for key in data.keys():
+            return key
         return None
 
     def get_duplicate_name(self, id: str) -> Tuple[str, str]:
@@ -331,6 +332,7 @@ class Presets:
         self.items[id].filename = id
         self.items[id].uuid = str(uuid.uuid4())
         self.sort_by_name()
+        self._order_append_new_item(id)
         return id
 
     def remove(
@@ -345,7 +347,10 @@ class Presets:
         :param remove_file: also remove preset JSON config file
         """
         if id in self.items:
+            item = self.items[id]
+            rem_uuid = item.uuid
             self.items.pop(id)
+            self._order_remove_uuid(rem_uuid)
 
         if remove_file:
             self.provider.remove(id)
@@ -366,6 +371,7 @@ class Presets:
         :param preset: preset item
         """
         self.items[preset.filename] = preset
+        self._order_append_new_item(preset.filename)
 
     def update_and_save(self, preset: PresetItem):
         """
@@ -375,6 +381,7 @@ class Presets:
         """
         self.items[preset.filename] = preset
         self.save(preset.filename)
+        self._order_append_new_item(preset.filename)
 
     def get_all(self) -> Dict[str, PresetItem]:
         """
@@ -411,6 +418,7 @@ class Presets:
         self.patch_duplicated()
         self.sort_by_name()
         self.append_current()
+        self._order_sync_all()
 
     def save(self, id: str):
         """
@@ -484,4 +492,183 @@ class Presets:
                 patched = True
             uuids.add(item.uuid)
         if patched:
-            self.save_all()
+            self.save_all()
+
+    # ----------------------------
+    # Ordering (drag & drop) logic
+    # ----------------------------
+
+    def _cfg_get(self, key, default=None):
+        try:
+            return self.window.core.config.get(key)
+        except Exception:
+            return default
+
+    def _cfg_set(self, key, value):
+        try:
+            self.window.core.config.set(key, value)
+        except Exception:
+            pass
+
+    def _dnd_enabled(self) -> bool:
+        """
+        Check global switch for DnD ordering.
+        """
+        v = self._cfg_get('presets.drag_and_drop.enabled', False)
+        return bool(v)
+
+    @staticmethod
+    def _is_special_id(pid: str) -> bool:
+        """
+        current.* presets are special and pinned at top; not movable.
+        """
+        return pid.startswith("current.")
+
+    def _uuid_to_id_map(self) -> Dict[str, str]:
+        return {item.uuid: pid for pid, item in self.items.items() if item.uuid}
+
+    def _visible_ids_for_mode(self, mode: str) -> List[str]:
+        attr = self._MODE_TO_ATTR.get(mode)
+        if not attr:
+            return []
+        return [pid for pid, it in self.items.items() if getattr(it, attr, False)]
+
+    def _visible_regular_ids_for_mode(self, mode: str) -> List[str]:
+        return [pid for pid in self._visible_ids_for_mode(mode) if not self._is_special_id(pid)]
+
+    def _visible_regular_uuids_for_mode(self, mode: str) -> List[str]:
+        ids = self._visible_regular_ids_for_mode(mode)
+        return [self.items[pid].uuid for pid in ids if pid in self.items and self.items[pid].uuid]
+
+    def _build_global_uuid_order(self) -> List[str]:
+        """
+        Rebuild 'global' order each time based on name-sorted presets (excluding current.*).
+        """
+        regs = [(pid, it) for pid, it in self.items.items() if not self._is_special_id(pid)]
+        regs.sort(key=lambda x: x[1].name)
+        return [it.uuid for pid, it in regs if it.uuid]
+
+    def _order_get_store(self) -> Dict[str, List[str]]:
+        store = self._cfg_get('presets_order', {}) or {}
+        fixed = {}
+        for k, v in store.items():
+            if isinstance(v, dict):
+                try:
+                    seq = [v[i] for i in sorted(v.keys(), key=lambda x: int(x))]
+                except Exception:
+                    seq = list(v.values())
+                fixed[k] = seq
+            elif isinstance(v, list):
+                fixed[k] = v
+        return fixed
+
+    def _order_set_store(self, store: Dict[str, List[str]]):
+        self._cfg_set('presets_order', store)
+
+    def _order_sync_mode(self, mode: str, store: Dict[str, List[str]]) -> List[str]:
+        """
+        Ensure mode order is valid:
+        - Start from mode order or fallback to global
+        - Drop unknown UUIDs
+        - Append missing visible UUIDs at the end
+        """
+        visible = self._visible_regular_uuids_for_mode(mode)
+        visible_set = set(visible)
+
+        base = list(store.get(mode) or [])
+        if not base:
+            base = [u for u in store.get('global', []) if u in visible_set]
+
+        base = [u for u in base if u in visible_set]
+
+        seen = set(base)
+        for u in visible:
+            if u not in seen:
+                base.append(u)
+                seen.add(u)
+
+        dedup = []
+        s = set()
+        for u in base:
+            if u not in s:
+                dedup.append(u)
+                s.add(u)
+
+        store[mode] = dedup
+        return dedup
+
+    def _order_sync_all(self):
+        """
+        Sync presets_order with current items and rebuild 'global' each time.
+        """
+        store = self._order_get_store()
+        store['global'] = self._build_global_uuid_order()
+
+        existing = set([it.uuid for it in self.items.values() if it.uuid])
+        for k, lst in list(store.items()):
+            if isinstance(lst, list):
+                store[k] = [u for u in lst if u in existing]
+
+        for mode in self._MODE_TO_ATTR.keys():
+            self._order_sync_mode(mode, store)
+
+        self._order_set_store(store)
+
+    def _ordered_ids_for_mode(self, mode: str) -> List[str]:
+        """
+        Produce ordered preset IDs for given mode:
+        - current.<mode> first (if exists)
+        - then remaining items by order stored as UUIDs
+        """
+        attr = self._MODE_TO_ATTR.get(mode)
+        if not attr:
+            return []
+        store = self._order_get_store()
+        ordered_uuids = self._order_sync_mode(mode, store)
+        self._order_set_store(store)
+
+        uuid_to_id = self._uuid_to_id_map()
+        head_id = f"current.{mode}"
+        out: List[str] = []
+        if head_id in self.items and getattr(self.items[head_id], attr, False):
+            out.append(head_id)
+        for u in ordered_uuids:
+            pid = uuid_to_id.get(u)
+            if pid and getattr(self.items.get(pid, PresetItem()), attr, False):
+                out.append(pid)
+        return out
+
+    def _order_append_new_item(self, pid: str):
+        """
+        Append new preset (by ID) to the end of all applicable mode orders.
+        """
+        if pid not in self.items:
+            return
+        if self._is_special_id(pid):
+            return
+        item = self.items[pid]
+        if not item.uuid:
+            return
+        store = self._order_get_store()
+        modes = [m for m, attr in self._MODE_TO_ATTR.items() if getattr(item, attr, False)]
+        for m in modes:
+            seq = list(store.get(m) or [])
+            if item.uuid not in seq:
+                seq.append(item.uuid)
+                store[m] = seq
+        self._order_set_store(store)
+
+    def _order_remove_uuid(self, rem_uuid: Optional[str]):
+        """
+        Remove a UUID from all order lists (including global).
+        """
+        if not rem_uuid:
+            return
+        store = self._order_get_store()
+        changed = False
+        for k, lst in list(store.items()):
+            if isinstance(lst, list) and rem_uuid in lst:
+                store[k] = [u for u in lst if u != rem_uuid]
+                changed = True
+        if changed:
+            self._order_set_store(store)

pygpt_net/core/render/markdown/parser.py

@@ -63,8 +63,6 @@ class Parser:
             html = self.md.convert(text.strip())
             soup = BeautifulSoup(html, 'html.parser')
             self.strip_whitespace_lists(soup)  # strip whitespace from codeblocks
-            if self.window.core.config.get("ctx.convert_lists"):
-                self.convert_lists_to_paragraphs(soup)  # convert lists to paragraphs
             self.strip_whitespace_codeblocks(soup)  # strip whitespace from codeblocks
             self.parse_code_blocks(soup)  # parse code blocks
             self.format_images(soup)  # add width to img tags