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

pygpt_net/controller/presets/presets.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 re
@@ -24,12 +24,14 @@ from pygpt_net.core.types import (
     MODE_AGENT_OPENAI,
 )
 from pygpt_net.controller.presets.editor import Editor
+    # Editor controller
 from pygpt_net.core.events import AppEvent
 from pygpt_net.item.preset import PresetItem
 from pygpt_net.utils import trans
 
 
 _FILENAME_SANITIZE_RE = re.compile(r'[^a-zA-Z0-9_\-\.]')
+# keep original validation (do not break other parts)
 _VALIDATE_FILENAME_RE = re.compile(r'[^\w\s\-\.]')
 
 
@@ -76,7 +78,7 @@ class Presets:
 
     def select(self, idx: int):
         """
-        Select preset
+        Select preset by list index (legacy)
 
         :param idx: value of the list (row idx)
         """
@@ -94,6 +96,32 @@ class Presets:
         if editor_ctrl.opened and editor_ctrl.current != preset_id:
             self.editor.init(preset_id)
 
+    def select_by_id(self, preset_id: str):
+        """
+        Select preset by explicit ID (robust for DnD-ordered views).
+        """
+        if self.preset_change_locked():
+            return
+        if not preset_id:
+            return
+        w = self.window
+        mode = w.core.config.get('mode')
+        if not w.core.presets.has(mode, preset_id):
+            return
+        w.core.config.set("preset", preset_id)
+        if 'current_preset' not in w.core.config.data:
+            w.core.config.data['current_preset'] = {}
+        w.core.config.data['current_preset'][mode] = preset_id
+        self.select_model()
+        w.controller.ui.update()
+        w.controller.model.select_current()
+        w.dispatch(AppEvent(AppEvent.PRESET_SELECTED))
+        idx = w.core.presets.get_idx_by_id(mode, preset_id)
+        self.set_selected(idx)
+        editor_ctrl = w.controller.presets.editor
+        if editor_ctrl.opened and editor_ctrl.current != preset_id:
+            self.editor.init(preset_id)
+
     def get_current(self) -> Optional[PresetItem]:
         """
         Get current preset
@@ -584,6 +612,43 @@ class Presets:
         if mode == MODE_ASSISTANT:
             w.core.assistants.load()
 
+    def _nearest_id_after_delete(self, mode: str, idx: Optional[int], deleting_id: Optional[str]) -> Optional[str]:
+        """
+        Compute the nearest neighbor to select after deletion:
+        - Prefer the next item (below) if exists;
+        - Otherwise choose the previous one (above);
+        - Returns None when no neighbor can be determined.
+        This uses the current view order for the given mode, including pinned current.<mode> at index 0.
+        """
+        try:
+            w = self.window
+            data = w.core.presets.get_by_mode(mode) or {}
+            ids = list(data.keys())
+            if not ids:
+                return None
+
+            # If idx is invalid, try to resolve from deleting_id
+            if idx is None or idx < 0 or idx >= len(ids):
+                if deleting_id and deleting_id in ids:
+                    idx = ids.index(deleting_id)
+                else:
+                    return None
+
+            # Prefer below
+            if idx + 1 < len(ids):
+                cand = ids[idx + 1]
+                if cand and cand != deleting_id:
+                    return cand
+
+            # Otherwise above
+            if idx - 1 >= 0:
+                cand = ids[idx - 1]
+                if cand and cand != deleting_id:
+                    return cand
+        except Exception:
+            pass
+        return None
+
     def delete(
             self,
             idx: Optional[int] = None,
@@ -607,10 +672,31 @@ class Presets:
                         msg=trans('confirm.preset.delete'),
                     )
                     return
-                if preset_id == w.core.config.get('preset'):
-                    w.core.config.set('preset', None)
-                    w.ui.nodes['preset.prompt'].setPlainText("")
+
+                # Determine neighbor only if the deleted preset is currently active.
+                # This keeps API semantics untouched and prevents unexpected selection changes.
+                is_current = (preset_id == w.core.config.get('preset'))
+                target_id = None
+                if is_current:
+                    target_id = self._nearest_id_after_delete(mode, idx, preset_id)
+
+                # Remove from core (also removes file when True)
                 w.core.presets.remove(preset_id, True)
+
+                # When removing the active preset, jump to the nearest neighbor (below or above).
+                # If no neighbor can be determined, fall back to previous behavior (clear and let defaults apply).
+                if is_current:
+                    if target_id and target_id in w.core.presets.items:
+                        # Persist new selection in config (and keep current_preset mapping coherent)
+                        w.core.config.set('preset', target_id)
+                        if 'current_preset' not in w.core.config.data:
+                            w.core.config.data['current_preset'] = {}
+                        w.core.config.data['current_preset'][mode] = target_id
+                    else:
+                        # Fallback: clear selection to allow select_default() to pick the first available
+                        w.core.config.set('preset', None)
+                        w.ui.nodes['preset.prompt'].setPlainText("")
+
                 self.refresh(no_scroll=True)
                 w.update_status(trans('status.preset.deleted'))
 
@@ -715,4 +801,33 @@ class Presets:
 
     def clear_selected(self):
         """Clear selected list"""
-        self.selected = []
+        self.selected = []
+
+    # ----------------------------
+    # Drag & drop ordering helpers
+    # ----------------------------
+
+    def persist_order_for_mode(self, mode: str, uuids: List[str]):
+        """
+        Persist new order (by UUIDs) for given mode.
+
+        The special '*' preset (current.<mode>) is not included here and always pinned at index 0.
+        """
+        w = self.window
+        cfg = w.core.config
+        order = cfg.get('presets_order') or {}
+        # Normalize to lists
+        if isinstance(order.get(mode), dict):
+            mapped = order.get(mode)
+            order[mode] = [mapped[k] for k in sorted(mapped.keys(), key=lambda x: int(x))]
+        order[mode] = [u for u in uuids if u]
+        cfg.set('presets_order', order)
+
+    def dnd_enabled(self) -> bool:
+        """
+        Check if drag and drop is globally enabled in config.
+        """
+        try:
+            return bool(self.window.core.config.get('presets.drag_and_drop.enabled'))
+        except Exception:
+            return False

pygpt_net/controller/settings/editor.py

@@ -51,11 +51,9 @@ class Editor:
         self.window.ui.add_hook("update.config.font_size.ctx", self.hook_update)
         self.window.ui.add_hook("update.config.font_size.toolbox", self.hook_update)
         self.window.ui.add_hook("update.config.zoom", self.hook_update)
-        self.window.ui.add_hook("update.config.theme.markdown", self.hook_update)
         self.window.ui.add_hook("update.config.vision.capture.enabled", self.hook_update)
         self.window.ui.add_hook("update.config.vision.capture.auto", self.hook_update)
         self.window.ui.add_hook("update.config.ctx.records.limit", self.hook_update)
-        self.window.ui.add_hook("update.config.ctx.convert_lists", self.hook_update)
         self.window.ui.add_hook("update.config.ctx.records.separators", self.hook_update)
         self.window.ui.add_hook("update.config.ctx.records.groups.separators", self.hook_update)
         self.window.ui.add_hook("update.config.ctx.records.pinned.separators", self.hook_update)
@@ -176,10 +174,6 @@ class Editor:
             value = self.window.core.config.get('theme.style')
             self.window.controller.theme.toggle_style(value)
 
-        # convert lists
-        if self.config_changed('ctx.convert_lists'):
-            self.window.controller.ctx.refresh()
-
         # access: voice control
         if self.config_changed('access.voice_control'):
             self.window.controller.access.voice.update()
@@ -266,19 +260,10 @@ class Editor:
             self.window.core.config.set(key, value)
             self.window.controller.ui.update_font_size()
 
-        # update markdown
-        elif key == "theme.markdown":
-            self.window.core.config.set(key, value)
-            self.window.controller.theme.markdown.update(force=True)
-
         elif key == "render.code_syntax":
             self.window.core.config.set(key, value)
             self.window.controller.theme.toggle_syntax(value, update_menu=True)
 
-        elif key == "ctx.convert_lists":
-            self.window.core.config.set(key, value)
-            self.window.controller.ctx.refresh()
-
         elif key == "ctx.records.separators":
             self.window.core.config.set(key, value)
             self.window.controller.ctx.update()

pygpt_net/controller/theme/markdown.py

@@ -33,11 +33,8 @@ class Markdown:
         """
         if force:
             self.window.controller.ui.store_state()  # store state before theme change
-
-        if self.window.core.config.get('theme.markdown'):
-            self.load()
-        else:
-            self.set_default()
+        
+        self.load()
         self.apply()
 
         if force:

pygpt_net/controller/ui/ui.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.23 15:00:00                  #
+# Updated Date: 2025.09.25 12:00:00                  #
 # ================================================== #
 
 from typing import Optional
@@ -15,7 +15,7 @@ from PySide6.QtGui import QColor
 
 from pygpt_net.core.types import MODE_IMAGE
 from pygpt_net.core.events import BaseEvent, Event
-from pygpt_net.utils import trans
+from pygpt_net.utils import trans, short_num
 
 from .mode import Mode
 from .tabs import Tabs
@@ -156,15 +156,12 @@ class UI:
         attachments_tokens = self.window.controller.chat.attachment.get_current_tokens()
         sum_tokens += attachments_tokens
 
-        ctx_string = f"{ctx_len} / {ctx_len_all} - {ctx_tokens} {trans('ctx.tokens')}"
+        ctx_string = f"{short_num(ctx_len)} / {short_num(ctx_len_all)} - {short_num(ctx_tokens)} {trans('ctx.tokens')}"
         if ctx_string != self._last_ctx_string:
             ui_nodes['prompt.context'].setText(ctx_string)
             self._last_ctx_string = ctx_string
 
-        parsed_sum = self.format_tokens(sum_tokens)
-        parsed_max_current = self.format_tokens(max_current)
-
-        input_string = f"{input_tokens} + {system_tokens} + {ctx_tokens} + {extra_tokens} + {attachments_tokens} = {parsed_sum} / {parsed_max_current}"
+        input_string = f"{short_num(input_tokens)} + {short_num(system_tokens)} + {short_num(ctx_tokens)} + {short_num(extra_tokens)} + {short_num(attachments_tokens)} = {short_num(sum_tokens)} / {short_num(max_current)}"
         if input_string != self._last_input_string:
             ui_nodes['input.counter'].setText(input_string)
             self._last_input_string = input_string

pygpt_net/core/agents/custom/__init__.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.25 14:00:00                  #
+# ================================================== #
+
+import copy
+from uuid import uuid4
+
+from pygpt_net.core.types import MODEL_DEFAULT
+from pygpt_net.item.agent import AgentItem
+from pygpt_net.item.builder_layout import BuilderLayoutItem
+from pygpt_net.provider.core.agent.json_file import JsonFileProvider
+from pygpt_net.utils import trans
+
+
+class Custom:
+
+    CUSTOM_AGENT_SUFFIX = " *"  # suffix for custom agents in lists
+
+    def __init__(self, window=None):
+        """
+        Custom agents core
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.provider = JsonFileProvider(window)  # JSON file provider
+        self.agents = {}  # dict of AgentItem
+        self.layout = None  # BuilderLayoutItem
+        self.loaded = False
+
+    def load(self):
+        """Load custom agents from provider"""
+        data = self.provider.load()
+        if "layout" in data:
+            self.layout = data["layout"]
+        if "agents" in data:
+            self.agents = data["agents"]
+        self.loaded = True
+
+    def reload(self):
+        """Reload custom agents from provider"""
+        self.loaded = False
+        self.load()
+
+    def save(self):
+        """Save custom agents to provider"""
+        self.provider.save(self.layout, self.agents)
+
+    def is_custom(self, agent_id: str) -> bool:
+        """
+        Check if agent is custom
+
+        :param agent_id: agent ID
+        :return: True if custom
+        """
+        if not self.loaded:
+            self.load()
+        return agent_id in self.agents
+
+    def update_layout(self, layout: dict):
+        """
+        Update current layout of custom agents editor
+
+        :param layout: layout dict
+        """
+        if self.layout is None:
+            self.layout = BuilderLayoutItem()
+        self.layout.data = layout
+
+    def reset(self):
+        """Reset custom agents"""
+        self.agents = {}
+        self.layout = None
+        self.loaded = False
+        self.provider.truncate()
+
+    def get_layout(self) -> dict:
+        """
+        Get layout of custom agents
+
+        :return: layout dict
+        """
+        if not self.loaded:
+            self.load()
+        return self.layout
+
+    def get_agents(self) -> dict:
+        """
+        Get custom agents
+
+        :return: dict of AgentItem
+        """
+        if not self.loaded:
+            self.load()
+        return self.agents
+
+    def get_choices(self) -> list:
+        """
+        Get custom agents choices
+
+        :return: list of dict with 'id' and 'name'
+        """
+        if not self.loaded:
+            self.load()
+        return [{agent.id: f"{agent.name}{self.CUSTOM_AGENT_SUFFIX}"} for agent in self.agents.values()]
+
+    def get_agent(self, agent_id: str):
+        """
+        Get custom agent by ID
+
+        :param agent_id: agent ID
+        :return: AgentItem or None
+        """
+        if not self.loaded:
+            self.load()
+        return self.agents.get(agent_id)
+
+    def get_ids(self) -> list:
+        """
+        Get list of custom agent IDs
+
+        :return: list of agent IDs
+        """
+        if not self.loaded:
+            self.load()
+        return list(self.agents.keys())
+
+    def get_schema(self, agent_id: str) -> list:
+        """
+        Get schema of a specific custom agent
+
+        :param agent_id: agent ID
+        :return: list with schema or empty list
+        """
+        if not self.loaded:
+            self.load()
+        agent = self.agents.get(agent_id)
+        if agent:
+            return agent.schema
+        return []
+
+    def build_options(self, agent_id: str) -> dict:
+        """
+        Build options for a specific custom agent
+
+        :param agent_id: agent ID
+        :return: dict with options or empty dict
+        """
+        if not self.loaded:
+            self.load()
+
+        agent = self.agents.get(agent_id)
+        if not agent:
+            return {}
+
+        schema = agent.schema if agent else []
+        options = {}
+        for node in schema:
+            try:
+                if "type" in node and node["type"] == "agent":
+                    if "id" in node:
+                        sub_agent_id = node["id"]
+                        tab = {
+                            "label": sub_agent_id
+                        }
+                        opts = {
+                            "model": {
+                                "label": trans("agent.option.model"),
+                                "type": "combo",
+                                "use": "models",
+                                "default": MODEL_DEFAULT,
+                            }
+                        }
+                        if "slots" in node:
+                            slots = node["slots"]
+                            if "name" in slots and slots["name"]:
+                                tab["label"] = slots["name"]
+                            if "role" in slots:
+                                opts["role"] = {
+                                    "type": "str",
+                                    "label": trans("agent.option.role"),
+                                    "default": slots["role"],
+                                }
+                            if "instruction" in slots:
+                                opts["prompt"] = {
+                                    "type": "textarea",
+                                    "label": trans("agent.option.prompt"),
+                                    "default": slots["instruction"],
+                                }
+                            if "remote_tools" in slots:
+                                opts["allow_remote_tools"] = {
+                                    "type": "bool",
+                                    "label": trans("agent.option.tools.remote"),
+                                    "description": trans("agent.option.tools.remote.desc"),
+                                    "default": slots["remote_tools"],
+                                }
+                            if "local_tools" in slots:
+                                opts["allow_local_tools"] = {
+                                    "type": "bool",
+                                    "label": trans("agent.option.tools.local"),
+                                    "description": trans("agent.option.tools.local.desc"),
+                                    "default": slots["local_tools"],
+                                }
+                        tab["options"] = opts
+                        options[sub_agent_id] = tab
+            except Exception as e:
+                self.window.core.debug.log(f"Failed to build options for custom agent '{agent_id}': {e}")
+                continue
+        return options
+
+    def new_agent(self, name: str):
+        """
+        Create new custom agent
+
+        :param name: agent name
+        """
+        if not self.loaded:
+            self.load()
+        new_id = str(uuid4())
+        new_agent = AgentItem()
+        new_agent.id = new_id
+        new_agent.name = name
+        self.agents[new_id] = new_agent
+        self.save()
+        return new_id
+
+    def duplicate_agent(self, agent_id: str, new_name: str):
+        """
+        Duplicate custom agent
+
+        :param agent_id: agent ID
+        :param new_name: new agent name
+        """
+        if not self.loaded:
+            self.load()
+        agent = self.agents.get(agent_id)
+        if agent:
+            new_agent = copy.deepcopy(agent)
+            new_agent.id = str(uuid4())
+            new_agent.name = new_name
+            self.agents[new_agent.id] = new_agent
+            self.save()
+
+    def delete_agent(self, agent_id: str):
+        """
+        Delete custom agent
+
+        :param agent_id: agent ID
+        """
+        if not self.loaded:
+            self.load()
+        if agent_id in self.agents:
+            del self.agents[agent_id]
+            self.save()
+
+    def update_agent(self, agent_id: str, layout: dict, schema: list):
+        """
+        Update layout and schema of a specific custom agent
+
+        :param agent_id: agent ID
+        :param layout: dictionary with new layout
+        :param schema: list with new schema
+        """
+        if not self.loaded:
+            self.load()
+        agent = self.agents.get(agent_id)
+        if agent:
+            if layout is None:
+                layout = {}
+            if schema is None:
+                schema = []
+            agent.layout = layout
+            agent.schema = schema
+            self.save()

pygpt_net/core/agents/custom/debug.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.24 23:00:00                  #
+# ================================================== #
+
+from __future__ import annotations
+from typing import Any, List, Optional
+
+from agents import TResponseInputItem
+
+
+def ellipsize(text: str, limit: int = 280) -> str:
+    """Shorten text for logs."""
+    if text is None:
+        return ""
+    s = str(text).replace("\n", " ").replace("\r", " ")
+    return s if len(s) <= limit else s[: max(0, limit - 3)] + "..."
+
+
+def content_to_text(content: Any) -> str:
+    """Convert 'content' which may be str or list[dict] to plain text for logs."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        out: List[str] = []
+        for part in content:
+            if isinstance(part, dict):
+                if "text" in part and isinstance(part["text"], str):
+                    out.append(part["text"])
+                elif part.get("type") in ("output_text", "input_text") and "text" in part:
+                    out.append(str(part["text"]))
+                else:
+                    # fallback – best-effort stringify
+                    t = part.get("text") or ""
+                    out.append(str(t))
+            else:
+                out.append(str(part))
+        return " ".join(out)
+    return str(content or "")
+
+
+def items_preview(items: List[TResponseInputItem], total_chars: int = 280, max_items: int = 4) -> str:
+    """
+    Produce compact preview of last N messages with roles and truncated content.
+    """
+    if not items:
+        return "(empty)"
+    pick = items[-max_items:]
+    per = max(32, total_chars // max(1, len(pick)))
+    lines: List[str] = []
+    for it in pick:
+        if not isinstance(it, dict):
+            lines.append(ellipsize(str(it), per))
+            continue
+        role = it.get("role", "?")
+        text = content_to_text(it.get("content"))
+        lines.append(f"- {role}: {ellipsize(text, per)}")
+    return " | ".join(lines)