pygpt-net 2.6.10__py3-none-any.whl → 2.6.12__py3-none-any.whl

pygpt_net/core/render/web/renderer.py

@@ -6,14 +6,16 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.16 00:00:00                  #
+# Updated Date: 2025.08.19 07:00:00                  #
 # ================================================== #
 
 import json
 import os
 import re
+
 from datetime import datetime
 from typing import Optional, List, Any
+from time import monotonic
 
 from pygpt_net.core.render.base import BaseRenderer
 from pygpt_net.core.text.utils import has_unclosed_code_tag
@@ -31,6 +33,7 @@ from pygpt_net.core.events import RenderEvent
 
 
 class Renderer(BaseRenderer):
+
     NODE_INPUT = 0
     NODE_OUTPUT = 1
     ENDINGS_CODE = (
@@ -43,6 +46,7 @@ class Renderer(BaseRenderer):
         "</ol>",
         "</li>"
     )
+    RE_AMP_LT_GT = re.compile(r'&amp;(lt|gt);')
 
     def __init__(self, window=None):
         super(Renderer, self).__init__(window)
@@ -55,7 +59,7 @@ class Renderer(BaseRenderer):
         self.body = Body(window)
         self.helpers = Helpers(window)
         self.parser = Parser(window)
-        self.pids = {}  # per node data
+        self.pids = {}
         self.prev_chunk_replace = False
         self.prev_chunk_newline = False
 
@@ -64,6 +68,9 @@ class Renderer(BaseRenderer):
         self._icon_sync = os.path.join(app_path, "data", "icons", "sync.svg")
         self._file_prefix = 'file:///' if self.window and self.window.core.platforms.is_windows() else 'file://'
 
+        self._thr = {}
+        self._throttle_interval = 0.01 # 10 ms delay
+
     def prepare(self):
         """
         Prepare renderer
@@ -82,7 +89,7 @@ class Renderer(BaseRenderer):
         self.parser.reset()
         try:
             node.page().runJavaScript("if (typeof window.prepare !== 'undefined') prepare();")
-        except Exception as e:
+        except Exception:
             pass
 
     def on_page_loaded(
@@ -102,8 +109,6 @@ class Renderer(BaseRenderer):
         if pid is None or pid not in self.pids:
             return
         self.pids[pid].loaded = True
-        node = self.get_output_node(meta)
-
         if self.pids[pid].html != "" and not self.pids[pid].use_buffer:
             self.clear_chunks_input(pid)
             self.clear_chunks_output(pid)
@@ -111,8 +116,6 @@ class Renderer(BaseRenderer):
             self.append(pid, self.pids[pid].html, flush=True)
             self.pids[pid].html = ""
 
-        node.setUpdatesEnabled(True)
-
     def get_pid(self, meta: CtxMeta):
         """
         Get PID for context meta
@@ -279,7 +282,7 @@ class Renderer(BaseRenderer):
         self.prev_chunk_replace = False
         try:
             self.get_output_node(meta).page().runJavaScript("beginStream();")
-        except Exception as e:
+        except Exception:
             pass
 
     def stream_end(
@@ -297,6 +300,9 @@ class Renderer(BaseRenderer):
         pid = self.get_or_create_pid(meta)
         if pid is None:
             return
+
+        self._throttle_emit(pid, force=True)
+        self._throttle_reset(pid)
         if self.window.controller.agent.legacy.enabled():
             if self.pids[pid].item is not None:
                 self.append_context_item(meta, self.pids[pid].item)
@@ -304,7 +310,7 @@ class Renderer(BaseRenderer):
         self.pids[pid].clear()
         try:
             self.get_output_node(meta).page().runJavaScript("endStream();")
-        except Exception as e:
+        except Exception:
             pass
 
     def append_context(
@@ -333,6 +339,7 @@ class Renderer(BaseRenderer):
         self.pids[pid].use_buffer = True
         self.pids[pid].html = ""
         prev_ctx = None
+        next_item = None
         total = len(items)
         for i, item in enumerate(items):
             self.update_names(meta, item)
@@ -347,14 +354,17 @@ class Renderer(BaseRenderer):
                 next_ctx=next_item
             )
             prev_ctx = item
-        self.pids[pid].use_buffer = False
 
+        prev_ctx = None
+        next_item = None
+        self.pids[pid].use_buffer = False
         if self.pids[pid].html != "":
             self.append(
                 pid,
                 self.pids[pid].html,
                 flush=True
             )
+        self.parser.reset()
 
     def append_input(
             self, meta: CtxMeta,
@@ -465,6 +475,8 @@ class Renderer(BaseRenderer):
         if not text_chunk:
             if begin:
                 pctx.clear()
+                self._throttle_emit(pid, force=True)
+                self._throttle_reset(pid)
             return
 
         name_header_str = self.get_name_header(ctx)
@@ -477,8 +489,10 @@ class Renderer(BaseRenderer):
                 debug = self.append_debug(ctx, pid, "stream")
                 if debug:
                     text_chunk = debug + text_chunk
-            pctx.clear()  # reset buffer
-            pctx.is_cmd = False  # reset command flag
+            self._throttle_emit(pid, force=True)
+            self._throttle_reset(pid)
+            pctx.clear()
+            pctx.is_cmd = False
             self.clear_chunks_output(pid)
             self.prev_chunk_replace = False
 
@@ -491,53 +505,43 @@ class Renderer(BaseRenderer):
             buffer_to_parse = buffer
 
         html = self.parser.parse(buffer_to_parse)
+        del buffer_to_parse
         is_code_block = html.endswith(self.ENDINGS_CODE)
         is_list = html.endswith(self.ENDINGS_LIST)
-        is_newline = ("\n" in text_chunk) or buffer.endswith("\n") or is_code_block
+        is_n = "\n" in text_chunk
+        is_newline = is_n or buffer.endswith("\n") or is_code_block
         force_replace = False
         if self.prev_chunk_newline:
             force_replace = True
-        if "\n" in text_chunk:
+        if is_n:
             self.prev_chunk_newline = True
         else:
             self.prev_chunk_newline = False
 
-        replace_bool = False
+        replace = False
         if is_newline or force_replace or is_list:
-            replace_bool = True
+            replace = True
             if is_code_block:
-                # don't replace if it is a code block
-                if "\n" not in text_chunk:
-                    # if there is no newline in raw_chunk, then don't replace
-                    replace_bool = False
+                if not is_n:
+                    replace = False
 
         if not is_code_block:
-            text_chunk = text_chunk.replace("\n", "<br/>")
+            if is_n:
+                text_chunk = text_chunk.replace("\n", "<br/>")
         else:
-            if self.prev_chunk_replace and not has_unclosed_code_tag(text_chunk):
-                # if previous chunk was replaced and current is code block, then add \n to chunk
-                text_chunk = "".join(("\n", text_chunk))  # add newline to chunk
+            if self.prev_chunk_replace and (is_code_block and not has_unclosed_code_tag(text_chunk)):
+                text_chunk = "\n" + text_chunk
 
-        self.prev_chunk_replace = replace_bool
+        self.prev_chunk_replace = replace
 
-        # hide loading spinner if it is the beginning of the text
         if begin:
             try:
                 self.get_output_node(meta).page().runJavaScript("hideLoading();")
-            except Exception as e:
+            except Exception:
                 pass
 
-        # emit chunk to output node
-        try:
-            self.get_output_node(meta).page().bridge.chunk.emit(
-                name_header_str or "",
-                html if replace_bool else "",
-                text_chunk if not replace_bool else "",
-                bool(replace_bool),
-                bool(is_code_block),
-            )
-        except Exception as e:
-            pass
+        self._throttle_queue(pid, name_header_str or "", html, text_chunk, replace, bool(is_code_block))
+        self._throttle_emit(pid, force=False)
 
     def next_chunk(
             self,
@@ -551,6 +555,8 @@ class Renderer(BaseRenderer):
         :param ctx: context item
         """
         pid = self.get_or_create_pid(meta)
+        self._throttle_emit(pid, force=True)
+        self._throttle_reset(pid)
         self.pids[pid].item = ctx
         self.pids[pid].buffer = ""
         self.update_names(meta, ctx)
@@ -558,8 +564,9 @@ class Renderer(BaseRenderer):
         self.prev_chunk_newline = False
         try:
             self.get_output_node(meta).page().runJavaScript(
-                "nextStream();")
-        except Exception as e:
+                "nextStream();"
+            )
+        except Exception:
             pass
 
     def append_chunk_input(
@@ -586,9 +593,13 @@ class Renderer(BaseRenderer):
         self.clear_chunks_input(pid)
         try:
             self.get_output_node(meta).page().runJavaScript(
-                f"appendToInput({self.to_json(self.helpers.format_chunk(text_chunk))});"
+                f"""appendToInput({self.to_json(
+                    self.sanitize_html(
+                        self.helpers.format_chunk(text_chunk)
+                    )
+                )});"""
             )
-        except Exception as e:
+        except Exception:
             pass
 
     def append_live(
@@ -630,9 +641,14 @@ class Renderer(BaseRenderer):
             to_append += "\n```"
         try:
             self.get_output_node(meta).page().runJavaScript(
-                f"replaceLive({self.to_json(self.parser.parse(to_append))});"
+                f"""replaceLive({self.to_json(
+                    self.sanitize_html(
+                        self.parser.parse(to_append)
+                    )
+                )});"""
             )
         except Exception as e:
+            print(e)
             pass
 
     def clear_live(self, meta: CtxMeta, ctx: CtxItem):
@@ -651,7 +667,7 @@ class Renderer(BaseRenderer):
             js = "clearLive();"
         try:
             self.get_output_node_by_pid(pid).page().runJavaScript(js)
-        except Exception as e:
+        except Exception:
             pass
 
     def append_node(
@@ -704,8 +720,9 @@ class Renderer(BaseRenderer):
         """
         if self.pids[pid].loaded and not self.pids[pid].use_buffer:
             self.clear_chunks(pid)
-            self.flush_output(pid, html)
-            self.pids[pid].html = ""
+            if html:
+                self.flush_output(pid, html)
+            self.pids[pid].clear()
         else:
             if not flush:
                 self.pids[pid].append_html(html)
@@ -824,7 +841,11 @@ class Renderer(BaseRenderer):
                 self.append(pid, html)
             else:
                 try:
-                    self.get_output_node(meta).page().runJavaScript(f"appendExtra('{ctx.id}',{self.to_json(html)});")
+                    self.get_output_node(meta).page().runJavaScript(
+                        f"""appendExtra('{ctx.id}',{self.to_json(
+                            self.sanitize_html(html)
+                        )});"""
+                    )
                 except Exception as e:
                     pass
 
@@ -894,6 +915,7 @@ class Renderer(BaseRenderer):
             node.reset_current_content()
         self.reset_names_by_pid(pid)
         self.prev_chunk_replace = False
+        self._throttle_reset(pid)
 
     def clear_input(self):
         """Clear input"""
@@ -939,7 +961,7 @@ class Renderer(BaseRenderer):
             js = "clearInput();"
         try:
             self.get_output_node_by_pid(pid).page().runJavaScript(js)
-        except Exception as e:
+        except Exception:
             pass
 
     def clear_chunks_output(
@@ -958,8 +980,9 @@ class Renderer(BaseRenderer):
             js = "clearOutput();"
         try:
             self.get_output_node_by_pid(pid).page().runJavaScript(js)
-        except Exception as e:
+        except Exception:
             pass
+        self._throttle_reset(pid)
 
     def clear_nodes(
             self,
@@ -976,7 +999,7 @@ class Renderer(BaseRenderer):
             js = "clearNodes();"
         try:
             self.get_output_node_by_pid(pid).page().runJavaScript(js)
-        except Exception as e:
+        except Exception:
             pass
 
     def prepare_node(
@@ -1174,10 +1197,11 @@ class Renderer(BaseRenderer):
         """
         try:
             self.get_output_node_by_pid(pid).page().runJavaScript(
-                f"if (typeof window.appendNode !== 'undefined') appendNode({self.to_json(html)});"
+                f"""if (typeof window.appendNode !== 'undefined') appendNode({self.to_json(self.sanitize_html(html))});"""
             )
-        except Exception as e:
+        except Exception:
             pass
+        html = None
 
     def reload(self):
         """Reload output, called externally only on theme change to redraw content"""
@@ -1213,17 +1237,10 @@ class Renderer(BaseRenderer):
         pid = self.get_or_create_pid(meta)
         if pid is None:
             return
-        html = self.body.get_html(pid)
-        self.pids[pid].loaded = False
         node = self.get_output_node_by_pid(pid)
         if node is not None:
-            # hard reset
-            # old_view = node
-            # new_view = old_view.hard_reset()
-            # self.window.ui.nodes['output'][pid] = new_view
             node.resetPage()
-            node.setHtml(html, baseUrl="file://")
-        self.pids[pid].html = ""
+        self._throttle_reset(pid)
 
     def get_output_node(
             self,
@@ -1266,7 +1283,7 @@ class Renderer(BaseRenderer):
         try:
             self.get_output_node(ctx.meta).page().runJavaScript(
                 f"if (typeof window.removeNode !== 'undefined') removeNode({self.to_json(ctx.id)});")
-        except Exception as e:
+        except Exception:
             pass
 
     def remove_items_from(self, ctx: CtxItem):
@@ -1278,7 +1295,7 @@ class Renderer(BaseRenderer):
         try:
             self.get_output_node(ctx.meta).page().runJavaScript(
                 f"if (typeof window.removeNodesFromId !== 'undefined') removeNodesFromId({self.to_json(ctx.id)});")
-        except Exception as e:
+        except Exception:
             pass
 
     def reset_names(self, meta: CtxMeta):
@@ -1329,7 +1346,7 @@ class Renderer(BaseRenderer):
             nodes = self.get_all_nodes()
             for node in nodes:
                 node.page().runJavaScript("if (typeof window.enableEditIcons !== 'undefined') enableEditIcons();")
-        except Exception as e:
+        except Exception:
             pass
 
     def on_disable_edit(self, live: bool = True):
@@ -1344,7 +1361,7 @@ class Renderer(BaseRenderer):
             nodes = self.get_all_nodes()
             for node in nodes:
                 node.page().runJavaScript("if (typeof window.disableEditIcons !== 'undefined') disableEditIcons();")
-        except Exception as e:
+        except Exception:
             pass
 
     def on_enable_timestamp(self, live: bool = True):
@@ -1359,7 +1376,7 @@ class Renderer(BaseRenderer):
             nodes = self.get_all_nodes()
             for node in nodes:
                 node.page().runJavaScript("if (typeof window.enableTimestamp !== 'undefined') enableTimestamp();")
-        except Exception as e:
+        except Exception:
             pass
 
     def on_disable_timestamp(self, live: bool = True):
@@ -1374,7 +1391,7 @@ class Renderer(BaseRenderer):
             nodes = self.get_all_nodes()
             for node in nodes:
                 node.page().runJavaScript("if (typeof window.disableTimestamp !== 'undefined') disableTimestamp();")
-        except Exception as e:
+        except Exception:
             pass
 
     def update_names(
@@ -1402,6 +1419,7 @@ class Renderer(BaseRenderer):
             self.clear_chunks(pid)
             self.clear_nodes(pid)
             self.pids[pid].html = ""
+            self._throttle_reset(pid)
 
     def scroll_to_bottom(self):
         """Scroll to bottom"""
@@ -1469,9 +1487,11 @@ class Renderer(BaseRenderer):
         """
         try:
             self.get_output_node(meta).page().runJavaScript(
-                f"if (typeof window.appendToolOutput !== 'undefined') appendToolOutput({self.to_json(content)});"
+                f"""if (typeof window.appendToolOutput !== 'undefined') appendToolOutput({self.to_json(
+                    self.sanitize_html(content)
+                )});"""
             )
-        except Exception as e:
+        except Exception:
             pass
 
     def tool_output_update(
@@ -1487,9 +1507,11 @@ class Renderer(BaseRenderer):
         """
         try:
             self.get_output_node(meta).page().runJavaScript(
-                f"if (typeof window.updateToolOutput !== 'undefined') updateToolOutput({self.to_json(content)});"
+                f"""if (typeof window.updateToolOutput !== 'undefined') updateToolOutput({self.to_json(
+                    self.sanitize_html(content)
+                )});"""
             )
-        except Exception as e:
+        except Exception:
             pass
 
     def tool_output_clear(self, meta: CtxMeta):
@@ -1502,7 +1524,7 @@ class Renderer(BaseRenderer):
             self.get_output_node(meta).page().runJavaScript(
                 f"if (typeof window.clearToolOutput !== 'undefined') clearToolOutput();"
             )
-        except Exception as e:
+        except Exception:
             pass
 
     def tool_output_begin(self, meta: CtxMeta):
@@ -1515,7 +1537,7 @@ class Renderer(BaseRenderer):
             self.get_output_node(meta).page().runJavaScript(
                 f"if (typeof window.beginToolOutput !== 'undefined') beginToolOutput();"
             )
-        except Exception as e:
+        except Exception:
             pass
 
     def tool_output_end(self):
@@ -1524,9 +1546,20 @@ class Renderer(BaseRenderer):
             self.get_output_node().page().runJavaScript(
                 f"if (typeof window.endToolOutput !== 'undefined') endToolOutput();"
             )
-        except Exception as e:
+        except Exception:
             pass
 
+    def sanitize_html(self, html: str) -> str:
+        """
+        Sanitize HTML to prevent XSS attacks
+
+        :param html: HTML string to sanitize
+        :return: sanitized HTML string
+        """
+        if not html:
+            return ""
+        return self.RE_AMP_LT_GT.sub(r'&\1;', html)
+
     def append_debug(
             self,
             ctx: CtxItem,
@@ -1539,6 +1572,7 @@ class Renderer(BaseRenderer):
         :param ctx: context item
         :param pid: context PID
         :param title: debug title
+        :return: HTML debug info
         """
         if title is None:
             title = "debug"
@@ -1555,6 +1589,115 @@ class Renderer(BaseRenderer):
     def remove_pid(self, pid: int):
         """
         Remove PID from renderer
+
+        :param pid: context PID
         """
         if pid in self.pids:
-            del self.pids[pid]
+            del self.pids[pid]
+        self._thr.pop(pid, None)
+
+    def _throttle_get(self, pid: int) -> dict:
+        """
+        Return per-pid throttle state
+
+        :param pid: context PID
+        :return: throttle state dictionary
+        """
+        thr = self._thr.get(pid)
+        if thr is None:
+            thr = {"last": 0.0, "op": 0, "name": "", "replace_html": "", "append": [], "code": False}
+            self._thr[pid] = thr
+        return thr
+
+    def _throttle_reset(self, pid: Optional[int]):
+        """
+        Reset throttle state
+
+        :param pid: context PID
+        """
+        if pid is None:
+            return
+        thr = self._thr.get(pid)
+        if thr is None:
+            return
+        thr["op"] = 0
+        thr["name"] = ""
+        thr["replace_html"] = ""
+        thr["append"].clear()
+        thr["code"] = False
+
+    def _throttle_queue(
+            self,
+            pid: int,
+            name: str,
+            html: str,
+            text_chunk: str,
+            replace: bool,
+            is_code_block: bool
+    ):
+        """
+        Queue chunk for throttled emit
+
+        :param pid: context PID
+        :param name: name of the chunk
+        :param html: HTML content of the chunk
+        :param text_chunk: raw text chunk
+        :param replace: whether to replace the current content
+        :param is_code_block: whether the chunk is a code block
+        """
+        thr = self._throttle_get(pid)
+        if name:
+            thr["name"] = name
+        if replace:
+            thr["op"] = 1
+            thr["replace_html"] = html
+            thr["append"].clear()
+            thr["code"] = bool(is_code_block)
+        else:
+            if thr["op"] != 1:
+                thr["op"] = 2
+            thr["append"].append(text_chunk)
+            thr["code"] = bool(is_code_block)
+
+    def _throttle_emit(self, pid: int, force: bool = False):
+        """
+        Emit queued chunks if due
+
+        :param pid: context PID
+        :param force: force emit regardless of throttle interval
+        """
+        thr = self._throttle_get(pid)
+        now = monotonic()
+        if not force and (now - thr["last"] < self._throttle_interval):
+            return
+        if thr["op"] == 1:
+            try:
+                node = self.get_output_node_by_pid(pid)
+                if node is not None:
+                    node.page().bridge.chunk.emit(
+                        thr["name"],
+                        self.sanitize_html(thr["replace_html"]),
+                        "",
+                        True,
+                        bool(thr["code"]),
+                    )
+            except Exception:
+                pass
+            thr["last"] = now
+            self._throttle_reset(pid)
+        elif thr["op"] == 2 and thr["append"]:
+            append_str = "".join(thr["append"])
+            try:
+                node = self.get_output_node_by_pid(pid)
+                if node is not None:
+                    node.page().bridge.chunk.emit(
+                        thr["name"],
+                        "",
+                        self.sanitize_html(append_str),
+                        False,
+                        bool(thr["code"]),
+                    )
+            except Exception:
+                pass
+            thr["last"] = now
+            self._throttle_reset(pid)

pygpt_net/data/config/config.json

@@ -1,8 +1,8 @@
 {
   "__meta__": {
-    "version": "2.6.10",
-    "app.version": "2.6.10",
-    "updated_at": "2025-08-17T00:00:00"
+    "version": "2.6.12",
+    "app.version": "2.6.12",
+    "updated_at": "2025-08-19T00:00:00"
   },
   "access.audio.event.speech": false,
   "access.audio.event.speech.disabled": [],

pygpt_net/data/config/models.json

@@ -1,8 +1,8 @@
 {
     "__meta__": {
-        "version": "2.6.10",
-        "app.version": "2.6.10",
-        "updated_at": "2025-08-17T23:07:35"
+        "version": "2.6.12",
+        "app.version": "2.6.12",
+        "updated_at": "2025-08-19T23:07:35"
     },
     "items": {
         "SpeakLeash/bielik-11b-v2.3-instruct:Q4_K_M": {

pygpt_net/data/config/presets/agent_openai.json

@@ -21,7 +21,7 @@
         "function": []
     },
     "experts": [],
-    "idx": "base",
+    "idx": "_",
     "agent_provider": "openai",
     "assistant_id": "",
     "enabled": true,

pygpt_net/data/config/presets/agent_openai_assistant.json

@@ -21,7 +21,7 @@
         "function": []
     },
     "experts": [],
-    "idx": "base",
+    "idx": "_",
     "agent_provider": "openai_assistant",
     "assistant_id": "",
     "enabled": true,

pygpt_net/data/config/presets/agent_planner.json

@@ -21,7 +21,7 @@
         "function": []
     },
     "experts": [],
-    "idx": "base",
+    "idx": "_",
     "agent_provider": "planner",
     "assistant_id": "",
     "enabled": true,

pygpt_net/data/config/presets/agent_react.json

@@ -21,7 +21,7 @@
         "function": []
     },
     "experts": [],
-    "idx": "base",
+    "idx": "_",
     "agent_provider": "react",
     "assistant_id": "",
     "enabled": true,