pygpt-net 2.6.1__py3-none-any.whl → 2.6.6__py3-none-any.whl

pygpt_net/core/render/web/renderer.py

@@ -6,17 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.14 01:00:00                  #
+# Updated Date: 2025.08.16 00:00:00                  #
 # ================================================== #
 
-import html
 import json
 import os
 import re
 from datetime import datetime
-from typing import Optional, List, Dict
-
-from PySide6.QtCore import QTimer
+from typing import Optional, List
 
 from pygpt_net.core.render.base import BaseRenderer
 from pygpt_net.core.text.utils import has_unclosed_code_tag
@@ -36,6 +33,16 @@ from pygpt_net.core.events import RenderEvent
 class Renderer(BaseRenderer):
     NODE_INPUT = 0
     NODE_OUTPUT = 1
+    ENDINGS_CODE = (
+        "</code></pre></div>",
+        "</code></pre></div><br/>",
+        "</code></pre></div><br>"
+    )
+    ENDINGS_LIST = (
+        "</ul>",
+        "</ol>",
+        "</li>"
+    )
 
     def __init__(self, window=None):
         super(Renderer, self).__init__(window)
@@ -51,16 +58,17 @@ class Renderer(BaseRenderer):
         self.pids = {}  # per node data
         self.prev_chunk_replace = False
         self.prev_chunk_newline = False
-        self._stream_flush_delay_ms = 12
-        self._stream_max_pending_bytes = 8192
-        self._stream_immediate_on_newline = True
-        self._stream_state: Dict[int, dict] = {}
+
+        app_path = self.window.core.config.get_app_path() if self.window else ""
+        self._icon_expand = os.path.join(app_path, "data", "icons", "expand.svg")
+        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://'
 
     def prepare(self):
         """
         Prepare renderer
         """
-        self.pids.clear()
+        self.pids = {}
 
     def on_load(self, meta: CtxMeta = None):
         """
@@ -73,7 +81,7 @@ class Renderer(BaseRenderer):
         self.reset(meta)
         self.parser.reset()
         try:
-            node.page().runJavaScript(f"if (typeof window.prepare !== 'undefined') prepare();")
+            node.page().runJavaScript("if (typeof window.prepare !== 'undefined') prepare();")
         except Exception as e:
             pass
 
@@ -88,28 +96,27 @@ class Renderer(BaseRenderer):
         :param meta: context meta
         :param tab: Tab
         """
-        if meta is None:
+        if meta is None or tab is None:
             return
         pid = tab.pid
         if pid is None or pid not in self.pids:
             return
-        p = self.pids[pid]
-        p.loaded = True
+        self.pids[pid].loaded = True
         node = self.get_output_node(meta)
 
-        if p.html != "" and not p.use_buffer:
+        if self.pids[pid].html != "" and not self.pids[pid].use_buffer:
             self.clear_chunks_input(pid)
             self.clear_chunks_output(pid)
             self.clear_nodes(pid)
-            self.append(pid, p.html, flush=True)
-            p.html = ""
+            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
-        
+
         :param meta: context PID
         """
         return self.window.core.ctx.output.get_pid(meta)
@@ -117,7 +124,7 @@ class Renderer(BaseRenderer):
     def get_or_create_pid(self, meta: CtxMeta):
         """
         Get PID for context meta and create PID data (if not exists)
-        
+
         :param meta: context PID
         """
         if meta is not None:
@@ -133,7 +140,7 @@ class Renderer(BaseRenderer):
     ):
         """
         Create PID data
-        
+
         :param pid: PID
         :param meta: context meta
         """
@@ -163,7 +170,6 @@ class Renderer(BaseRenderer):
         :param state: state name
         :param meta: context meta
         """
-        # BUSY: current pid only
         if state == RenderEvent.STATE_BUSY:
             if meta:
                 pid = self.get_pid(meta)
@@ -171,29 +177,27 @@ class Renderer(BaseRenderer):
                     node = self.get_output_node_by_pid(pid)
                     try:
                         node.page().runJavaScript(
-                            f"if (typeof window.showLoading !== 'undefined') showLoading();")
+                            "if (typeof window.showLoading !== 'undefined') showLoading();")
                     except Exception as e:
                         pass
 
-        # IDLE: all pids
         elif state == RenderEvent.STATE_IDLE:
-            for pid in self.pids.keys():
+            for pid in self.pids:
                 node = self.get_output_node_by_pid(pid)
                 if node is not None:
                     try:
                         node.page().runJavaScript(
-                            f"if (typeof window.hideLoading !== 'undefined') hideLoading();")
+                            "if (typeof window.hideLoading !== 'undefined') hideLoading();")
                     except Exception as e:
                         pass
 
-        # ERROR: all pids
         elif state == RenderEvent.STATE_ERROR:
-            for pid in self.pids.keys():
+            for pid in self.pids:
                 node = self.get_output_node_by_pid(pid)
                 if node is not None:
                     try:
                         node.page().runJavaScript(
-                            f"if (typeof window.hideLoading !== 'undefined') hideLoading();")
+                            "if (typeof window.hideLoading !== 'undefined') hideLoading();")
                     except Exception as e:
                         pass
 
@@ -213,7 +217,7 @@ class Renderer(BaseRenderer):
         pid = self.get_or_create_pid(meta)
         self.init(pid)
         self.reset_names(meta)
-        self.tool_output_end()  # reset tools
+        self.tool_output_end()
         self.prev_chunk_replace = False
 
     def end(
@@ -229,14 +233,13 @@ class Renderer(BaseRenderer):
         :param ctx: context item
         :param stream: True if it is a stream
         """
-        self._stream_state.clear()  # reset stream state
         pid = self.get_or_create_pid(meta)
         if pid is None:
             return
-        p = self.pids[pid]
-        if p.item is not None and stream:
-            self.append_context_item(meta, p.item)
-            p.item = None
+        if self.pids[pid].item is not None and stream:
+            self.append_context_item(meta, self.pids[pid].item)
+            self.pids[pid].item = None
+        self.pids[pid].clear()
 
     def end_extra(
             self,
@@ -246,7 +249,7 @@ class Renderer(BaseRenderer):
     ):
         """
         Render end extra
-        
+
         :param meta: context meta
         :param ctx: context item
         :param stream: True if it is a stream
@@ -260,10 +263,10 @@ class Renderer(BaseRenderer):
     ):
         """
         Render stream begin
-        
+
         :param meta: context meta
         :param ctx: context item
-        """        
+        """
         self.prev_chunk_replace = False
         try:
             self.get_output_node(meta).page().runJavaScript("beginStream();")
@@ -277,23 +280,19 @@ class Renderer(BaseRenderer):
     ):
         """
         Render stream end
-        
+
         :param meta: context meta
         :param ctx: context item
         """
-        self._stream_state.clear()  # reset stream state
         self.prev_chunk_replace = False
         pid = self.get_or_create_pid(meta)
         if pid is None:
             return
-
-        p = self.pids[pid]
         if self.window.controller.agent.legacy.enabled():
-            if p.item is not None:
-                self.append_context_item(meta, p.item)
-                p.item = None
-
-        p.clear() # reset buffers
+            if self.pids[pid].item is not None:
+                self.append_context_item(meta, self.pids[pid].item)
+                self.pids[pid].item = None
+        self.pids[pid].clear()
         try:
             self.get_output_node(meta).page().runJavaScript("endStream();")
         except Exception as e:
@@ -307,7 +306,7 @@ class Renderer(BaseRenderer):
     ):
         """
         Append all context to output
-        
+
         :param meta: Context meta
         :param items: context items
         :param clear: True if clear all output before append
@@ -321,35 +320,32 @@ class Renderer(BaseRenderer):
 
         if clear:
             self.reset(meta)
-        i = 0
 
-        p = self.pids[pid]
-        p.use_buffer = True
-        p.html = ""
+        self.pids[pid].use_buffer = True
+        self.pids[pid].html = ""
         prev_ctx = None
-        for item in items:
+        total = len(items)
+        for i, item in enumerate(items):
             self.update_names(meta, item)
             item.idx = i
             if i == 0:
                 item.first = True
-            next_item = items[i + 1] if i + 1 < len(items) else None   # append next item if exists
+            next_item = items[i + 1] if i + 1 < total else None
             self.append_context_item(
                 meta,
                 item,
                 prev_ctx=prev_ctx,
                 next_ctx=next_item
-            )  # to html buffer
+            )
             prev_ctx = item
-            i += 1
-        p.use_buffer = False
+        self.pids[pid].use_buffer = False
 
-        # flush
-        if p.html != "":
+        if self.pids[pid].html != "":
             self.append(
                 pid,
-                p.html,
+                self.pids[pid].html,
                 flush=True
-            )  # flush buffer if page loaded, otherwise it will be flushed on page load
+            )
 
     def append_input(
             self, meta: CtxMeta,
@@ -365,7 +361,7 @@ class Renderer(BaseRenderer):
         :param flush: flush HTML
         :param append: True if force append node
         """
-        self.tool_output_end()  # reset tools
+        self.tool_output_end()
         pid = self.get_or_create_pid(meta)
         if not flush:
             self.clear_chunks_input(pid)
@@ -376,7 +372,6 @@ class Renderer(BaseRenderer):
 
         text = ctx.input
 
-        # if sub-reply
         if isinstance(ctx.extra, dict) and "sub_reply" in ctx.extra and ctx.extra["sub_reply"]:
             try:
                 json_encoded = json.loads(text)
@@ -387,18 +382,16 @@ class Renderer(BaseRenderer):
             except json.JSONDecodeError:
                 pass
 
-        # hidden internal call
         if ctx.internal \
                 and not ctx.first \
                 and not ctx.input.strip().startswith("user: ") \
-                and not ctx.input.strip().startswith("@"):  # expert says:
+                and not ctx.input.strip().startswith("@"):
             return
         else:
-            # don't show user prefix if provided in internal call goal update
             if ctx.internal and ctx.input.startswith("user: "):
                 text = re.sub(r'^user: ', '> ', ctx.input)
 
-        if flush:  # to chunk buffer
+        if flush:
             if self.is_stream() and not append:
                 content = self.prepare_node(meta, ctx, text.strip(), self.NODE_INPUT)
                 self.append_chunk_input(meta, ctx, content, False)
@@ -416,24 +409,22 @@ class Renderer(BaseRenderer):
     ):
         """
         Append text output to output
-        
+
         :param meta: context meta
         :param ctx: context item
         :param flush: flush HTML
         :param prev_ctx: previous context
         :param next_ctx: next context
         """
-        self.tool_output_end()  # reset tools
+        self.tool_output_end()
         output = ctx.output
-        if (isinstance(ctx.extra, dict)
-                and "output" in ctx.extra
-                and ctx.extra["output"]):
+        if isinstance(ctx.extra, dict) and ctx.extra.get("output"):
             if self.window.core.config.get("llama.idx.chat.agent.render.all", False):
-                output = "__agent_begin__" + ctx.output + "__agent_end__" + ctx.extra["output"]
+                output = f"__agent_begin__{ctx.output}__agent_end__{ctx.extra['output']}"
             else:
                 output = ctx.extra["output"]
         else:
-            if ctx.output is None or ctx.output == "":
+            if not output:
                 return
         self.append_node(
             meta=meta,
@@ -444,124 +435,6 @@ class Renderer(BaseRenderer):
             next_ctx=next_ctx
         )
 
-    def _get_stream_state(self, pid: int):
-        """
-        Get stream state for PID
-
-        :param pid: context PID
-        :return: dict – stream state
-        """
-        # pid state for micro chunk
-        st = self._stream_state.get(pid)
-        if st is None:
-            st = {
-                "pending": [],  # list[str] – uncommitted chunks
-                "pending_bytes": 0,  # fast check for flush
-                "scheduled": False,  # is flush scheduled?
-                "gen": 0,  # count of stream generations (for flush)
-                "last_ctx": None,  # last ctx for name_header
-                "last_meta": None,  # last meta (to get_output_node)
-            }
-            self._stream_state[pid] = st
-        return st
-
-    def _schedule_flush(
-            self,
-            pid: int,
-            gen: int,
-            delay_ms: int
-    ):
-        """
-        Schedule flush for stream output
-
-        :param pid: context PID
-        :param gen: generation number (to avoid flush on reset)
-        :param delay_ms: delay in milliseconds
-        """
-        # no leaks, only primitive closures
-        def _run():
-            # if reset or new generation, don't flush
-            st = self._stream_state.get(pid)
-            if not st or st["gen"] != gen:
-                return
-            self._flush_stream(pid)
-        QTimer.singleShot(max(0, int(delay_ms)), _run)
-
-    def _flush_stream(self, pid: int):
-        """
-        Flush stream output
-
-        :param pid: context PID
-        """
-        st = self._get_stream_state(pid)
-        if not st["pending"]:
-            st["scheduled"] = False
-            return
-
-        p = self.pids[pid]
-
-        # confirm cumulated chunks
-        raw_chunk = "".join(st["pending"])
-        st["pending"].clear()
-        st["pending_bytes"] = 0
-        st["scheduled"] = False
-
-        # header+update_names based on last ctx
-        ctx = st["last_ctx"] if st["last_ctx"] is not None else p.item
-        meta = st["last_meta"]
-
-        name_header = self.get_name_header(ctx)
-        self.update_names(meta, ctx)
-
-        # buffer commited only on flush (less copies)
-        # begin reset was already called in append_chunk gdy begin=True
-        p.append_buffer(raw_chunk)
-        buffer = p.buffer
-
-        has_unclosed = has_unclosed_code_tag
-        parse_buffer = buffer + "\n```" if has_unclosed(buffer) else buffer
-        html = self.parser.parse(parse_buffer)
-
-        code_endings = ("</code></pre></div>", "</code></pre></div><br/>", "</code></pre></div><br>")
-        list_endings = ("</ul>", "</ol>", "</li>")
-        is_code_block = html.endswith(code_endings)
-        is_list_block = html.endswith(list_endings)
-
-        newline_in_chunk = "\n" in raw_chunk
-        is_newline = newline_in_chunk or buffer.endswith("\n") or is_code_block or is_list_block
-
-        force_replace = self.prev_chunk_newline
-        self.prev_chunk_newline = newline_in_chunk
-
-        replace_bool = is_newline or force_replace
-        if is_code_block and not newline_in_chunk:
-            replace_bool = False
-
-        # prepare for DOM
-        out_chunk = raw_chunk
-        if not is_code_block:
-            out_chunk = out_chunk.replace("\n", "<br/>")
-        else:
-            if self.prev_chunk_replace and not has_unclosed(out_chunk):
-                out_chunk = "\n" + out_chunk
-
-        # JSON-escape
-        name_header_json = json.dumps(name_header)
-        html_json = json.dumps(html)
-        chunk_json = json.dumps(out_chunk)
-
-        self.prev_chunk_replace = replace_bool
-
-        replace_js = "true" if replace_bool else "false"
-        code_block_js = "true" if is_code_block else "false"
-
-        try:
-            self.get_output_node(meta).page().runJavaScript(
-                f"appendStream({name_header_json}, {html_json}, {chunk_json}, {replace_js}, {code_block_js});"
-            )
-        except Exception:
-            pass
-
     def append_chunk(
             self,
             meta: CtxMeta,
@@ -570,7 +443,7 @@ class Renderer(BaseRenderer):
             begin: bool = False
     ):
         """
-        Append output chunk to output (micro-batching + delay)
+        Append output chunk to output
 
         :param meta: context meta
         :param ctx: context item
@@ -578,56 +451,74 @@ class Renderer(BaseRenderer):
         :param begin: if it is the beginning of the text
         """
         pid = self.get_or_create_pid(meta)
-        p = self.pids[pid]
-        p.item = ctx
-
-        # empty chunk
+        pctx = self.pids[pid]
+        pctx.item = ctx
         if not text_chunk:
             if begin:
-                p.buffer = ""  # always reset buffer
+                pctx.clear()
             return
 
-        st = self._get_stream_state(pid)
-        st["last_ctx"] = ctx
-        st["last_meta"] = meta
+        name_header_str = self.get_name_header(ctx)
+        self.update_names(meta, ctx)
+        text_chunk = text_chunk if isinstance(text_chunk, str) else str(text_chunk)
+        text_chunk = text_chunk.translate({ord('<'): '&lt;', ord('>'): '&gt;'})
 
-        # on begin, reset generation and pending chunks
-        raw_chunk = text_chunk if isinstance(text_chunk, str) else str(text_chunk)
         if begin:
-            debug = self.append_debug(ctx, pid, "stream") if self.is_debug() else ""
-            if debug:
-                raw_chunk = debug + raw_chunk
-            p.buffer = ""  # reset buffer
-            p.is_cmd = False  # reset command flag
+            if self.is_debug():
+                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.clear_chunks_output(pid)
             self.prev_chunk_replace = False
 
-            # micro-batch reset
-            st["pending"].clear()
-            st["pending_bytes"] = 0
-            st["gen"] += 1
-            st["scheduled"] = False
-
-        # accumulation in list (no fragmentation by +=)
-        st["pending"].append(raw_chunk)
-        st["pending_bytes"] += len(raw_chunk)
-
-        # Flush:
-        # - immediate on newline/``` or huge amount of pending bytes
-        # - otherwise delay (12 ms)
-        immediate = False
-        if self._stream_immediate_on_newline and ("\n" in raw_chunk or "```" in raw_chunk):
-            immediate = True
-        if st["pending_bytes"] >= self._stream_max_pending_bytes:
-            immediate = True
-
-        if not st["scheduled"]:
-            st["scheduled"] = True
-            delay = 0 if immediate else self._stream_flush_delay_ms
-            gen_snapshot = st["gen"]
-            self._schedule_flush(pid, gen_snapshot, delay)
+        pctx.append_buffer(text_chunk)
+
+        buffer = pctx.buffer
+        if has_unclosed_code_tag(buffer):
+            buffer_to_parse = "".join((buffer, "\n```"))
+        else:
+            buffer_to_parse = buffer
+
+        html = self.parser.parse(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
+        force_replace = False
+        if self.prev_chunk_newline:
+            force_replace = True
+        if "\n" in text_chunk:
+            self.prev_chunk_newline = True
+        else:
+            self.prev_chunk_newline = False
+
+        replace_bool = False
+        if is_newline or force_replace or is_list:
+            replace_bool = 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_code_block:
+            text_chunk = text_chunk.replace("\n", "<br/>")
         else:
-            # already planned, flush will be executed later
+            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
+
+        self.prev_chunk_replace = replace_bool
+        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
 
     def next_chunk(
@@ -642,15 +533,14 @@ class Renderer(BaseRenderer):
         :param ctx: context item
         """
         pid = self.get_or_create_pid(meta)
-        p = self.pids[pid]
-        p.item = ctx
-        p.buffer = ""  # always reset buffer
+        self.pids[pid].item = ctx
+        self.pids[pid].buffer = ""
         self.update_names(meta, ctx)
         self.prev_chunk_replace = False
         self.prev_chunk_newline = False
         try:
             self.get_output_node(meta).page().runJavaScript(
-                f"nextStream();")
+                "nextStream();")
         except Exception as e:
             pass
 
@@ -699,32 +589,27 @@ class Renderer(BaseRenderer):
         :param begin: if it is the beginning of the text
         """
         pid = self.get_or_create_pid(meta)
-        p = self.pids[pid]
-        p.item = ctx
+        self.pids[pid].item = ctx
         if text_chunk is None or text_chunk == "":
             if begin:
-                p.live_buffer = ""  # always reset buffer
+                self.pids[pid].live_buffer = ""
             return
         self.update_names(meta, ctx)
-        raw_chunk = str(text_chunk)
-        raw_chunk = raw_chunk.replace("<", "&lt;")
-        raw_chunk = raw_chunk.replace(">", "&gt;")
+        raw_chunk = str(text_chunk).translate({ord('<'): '&lt;', ord('>'): '&gt;'})
         if begin:
-            # debug
             debug = ""
             if self.is_debug():
                 debug = self.append_debug(ctx, pid, "stream")
             if debug:
                 raw_chunk = debug + raw_chunk
-            p.live_buffer = ""  # reset buffer
-            p.is_cmd = False  # reset command flag
-            self.clear_live(meta, ctx)  # clear live output
-        p.append_live_buffer(raw_chunk)
-
-        # parse chunks
-        to_append = p.live_buffer
-        if has_unclosed_code_tag(p.live_buffer):
-            to_append += "\n```"  # fix for code block without closing ```
+            self.pids[pid].live_buffer = ""
+            self.pids[pid].is_cmd = False
+            self.clear_live(meta, ctx)
+        self.pids[pid].append_live_buffer(raw_chunk)
+
+        to_append = self.pids[pid].live_buffer
+        if has_unclosed_code_tag(self.pids[pid].live_buffer):
+            to_append += "\n```"
         html = self.parser.parse(to_append)
         escaped_chunk = json.dumps(html)
         try:
@@ -744,7 +629,7 @@ class Renderer(BaseRenderer):
             return
         pid = self.get_or_create_pid(meta)
         if not self.pids[pid].loaded:
-            js = "var element = document.getElementById('_append_live_'); if (element) { element.innerHTML = ''; }"
+            js = "var element = document.getElementById('_append_live_');if (element) { element.innerHTML = ''; }"
         else:
             js = "clearLive();"
         try:
@@ -795,19 +680,18 @@ class Renderer(BaseRenderer):
     ):
         """
         Append text to output
-        
+
         :param pid: ctx pid
         :param html: HTML code
         :param flush: True if flush only
         """
-        p = self.pids[pid]
-        if p.loaded and not p.use_buffer:
+        if self.pids[pid].loaded and not self.pids[pid].use_buffer:
             self.clear_chunks(pid)
-            self.flush_output(pid, html)  # render
-            p.html = ""
+            self.flush_output(pid, html)
+            self.pids[pid].html = ""
         else:
             if not flush:
-                p.append_html(html)  # to buffer
+                self.pids[pid].append_html(html)
 
     def append_context_item(
             self,
@@ -835,7 +719,7 @@ class Renderer(BaseRenderer):
             flush=False,
             prev_ctx=prev_ctx,
             next_ctx=next_ctx
-        )  # + extra
+        )
 
     def append_extra(
             self,
@@ -846,92 +730,87 @@ class Renderer(BaseRenderer):
     ) -> str:
         """
         Append extra data (images, files, etc.) to output
-        
+
         :param meta: context meta
         :param ctx: context item
         :param footer: True if it is a footer
         :param render: True if render, False if only return HTML
         :return: HTML code
         """
-        self.tool_output_end()  # reset tools
-        body = self.body
+        self.tool_output_end()
+
         pid = self.get_pid(meta)
-        p = self.pids.get(pid)
-        appended = []
-        html = ""
-        # images
+        appended = set()
+        html_parts = []
+
         c = len(ctx.images)
         if c > 0:
             n = 1
             for image in ctx.images:
                 if image is None:
                     continue
-                # don't append if it is an external url
-                # if image.startswith("http"):
-                    # continue
-                if image in appended or image in p.images_appended:
+                if image in appended or image in self.pids[pid].images_appended:
                     continue
                 try:
-                    appended.append(image)
-                    html += body.get_image_html(image, n, c)
-                    p.images_appended.append(image)
+                    appended.add(image)
+                    html_parts.append(self.body.get_image_html(image, n, c))
+                    self.pids[pid].images_appended.append(image)
                     n += 1
                 except Exception as e:
                     pass
 
-        # files and attachments, TODO check attachments
         c = len(ctx.files)
         if c > 0:
             files_html = []
             n = 1
             for file in ctx.files:
-                if file in appended or file in p.files_appended:
+                if file in appended or file in self.pids[pid].files_appended:
                     continue
                 try:
-                    appended.append(file)
-                    files_html.append(body.get_file_html(file, n, c))
-                    p.files_appended.append(file)
+                    appended.add(file)
+                    files_html.append(self.body.get_file_html(file, n, c))
+                    self.pids[pid].files_appended.append(file)
                     n += 1
                 except Exception as e:
                     pass
             if files_html:
-                html += "<br/>" + "<br/>".join(files_html)
+                html_parts.append("<br/><br/>".join(files_html))
 
-        # urls
         c = len(ctx.urls)
         if c > 0:
             urls_html = []
             n = 1
             for url in ctx.urls:
-                if url in appended or url in p.urls_appended:
+                if url in appended or url in self.pids[pid].urls_appended:
                     continue
                 try:
-                    appended.append(url)
-                    urls_html.append(body.get_url_html(url, n, c))
-                    p.urls_appended.append(url)
+                    appended.add(url)
+                    urls_html.append(self.body.get_url_html(url, n, c))
+                    self.pids[pid].urls_appended.append(url)
                     n += 1
                 except Exception as e:
                     pass
             if urls_html:
-                html += "<br/>" + "<br/>".join(urls_html)
+                html_parts.append("<br/><br/>".join(urls_html))
 
-        # docs json
         if self.window.core.config.get('ctx.sources'):
             if ctx.doc_ids is not None and len(ctx.doc_ids) > 0:
                 try:
-                    docs = body.get_docs_html(ctx.doc_ids)
-                    html += docs
+                    docs = self.body.get_docs_html(ctx.doc_ids)
+                    html_parts.append(docs)
                 except Exception as e:
                     pass
-        # flush
+
+        html = "".join(html_parts)
         if render and html != "":
             if footer:
-                # append to output
                 self.append(pid, html)
             else:
-                # append to existing message box using JS
                 escaped_html = json.dumps(html)
-                self.get_output_node(meta).page().runJavaScript("appendExtra('{}',{});".format(ctx.id, escaped_html))
+                try:
+                    self.get_output_node(meta).page().runJavaScript(f"appendExtra('{ctx.id}',{escaped_html});")
+                except Exception as e:
+                    pass
 
         return html
 
@@ -958,7 +837,7 @@ class Renderer(BaseRenderer):
             if timestamp is not None:
                 ts = datetime.fromtimestamp(timestamp)
                 hour = ts.strftime("%H:%M:%S")
-                text = '<span class="ts">{}: </span>{}'.format(hour, text)
+                text = f'<span class="ts">{hour}: </span>{text}'
         return text
 
     def reset(
@@ -971,16 +850,13 @@ class Renderer(BaseRenderer):
         :param meta: Context meta
         """
         pid = self.get_pid(meta)
-        if pid is not None and pid in self.pids:  # in PIDs only if at least one ctx item is appended
+        if pid is not None and pid in self.pids:
             self.reset_by_pid(pid)
         else:
-            # there is no pid here if empty context so check for meta, and clear current
             if meta is not None:
-                # create new PID using only meta
                 pid = self.get_or_create_pid(meta)
                 self.reset_by_pid(pid)
 
-        # clear live output
         self.clear_live(meta, CtxItem())
 
     def reset_by_pid(self, pid: Optional[int]):
@@ -989,15 +865,19 @@ class Renderer(BaseRenderer):
 
         :param pid: context PID
         """
-        p = self.pids.get(pid)
         self.parser.reset()
-        p.clear(all=True)
+        self.pids[pid].item = None
+        self.pids[pid].html = ""
         self.clear_nodes(pid)
         self.clear_chunks(pid)
-        self.get_output_node_by_pid(pid).reset_current_content()
+        self.pids[pid].images_appended = []
+        self.pids[pid].urls_appended = []
+        self.pids[pid].files_appended = []
+        node = self.get_output_node_by_pid(pid)
+        if node is not None:
+            node.reset_current_content()
         self.reset_names_by_pid(pid)
         self.prev_chunk_replace = False
-        self._stream_state.clear()  # reset stream state
 
     def clear_input(self):
         """Clear input"""
@@ -1038,8 +918,7 @@ class Renderer(BaseRenderer):
         if pid is None:
             return
         if not self.pids[pid].loaded:
-            js = "var element = document.getElementById('_append_input_');"
-            js += "if (element) { element.innerHTML = ''; }"
+            js = "var element = document.getElementById('_append_input_');if (element) { element.innerHTML = ''; }"
         else:
             js = "clearInput();"
         try:
@@ -1058,8 +937,7 @@ class Renderer(BaseRenderer):
         """
         self.prev_chunk_replace = False
         if not self.pids[pid].loaded:
-            js = "var element = document.getElementById('_append_output_');"
-            js += "if (element) { element.innerHTML = ''; }"
+            js = "var element = document.getElementById('_append_output_');if (element) { element.innerHTML = ''; }"
         else:
             js = "clearOutput();"
         try:
@@ -1077,8 +955,7 @@ class Renderer(BaseRenderer):
         :pid: context PID
         """
         if not self.pids[pid].loaded:
-            js = "var element = document.getElementById('_nodes_');"
-            js += "if (element) { element.innerHTML = ''; }"
+            js = "var element = document.getElementById('_nodes_');if (element) { element.innerHTML = ''; }"
         else:
             js = "clearNodes();"
         try:
@@ -1097,7 +974,7 @@ class Renderer(BaseRenderer):
     ) -> str:
         """
         Prepare node HTML
-        
+
         :param meta: context meta
         :param ctx: CtxItem instance
         :param html: html text
@@ -1142,48 +1019,42 @@ class Renderer(BaseRenderer):
         :param next_ctx: next context item
         :return: prepared HTML
         """
-        helpers = self.helpers
-        format_user_text = helpers.format_user_text
-        post_format_text = helpers.post_format_text
-        append_timestamp = self.append_timestamp
-        append_debug = self.append_debug
-        is_debug = self.is_debug
-        pids = self.pids
-        node_input = self.NODE_INPUT
-
-        msg_id = f"msg-user-{ctx.id}" if ctx is not None else ""
-
-        content = append_timestamp(
+        msg_id = "msg-user-" + str(ctx.id) if ctx is not None else ""
+        content = self.append_timestamp(
             ctx,
-            format_user_text(html),
-            type=node_input
+            self.helpers.format_user_text(html),
+            type=self.NODE_INPUT
         )
-        html = post_format_text(f"<p>{content}</p>")
+        html = f"<p>{content}</p>"
+        html = self.helpers.post_format_text(html)
+        name = self.pids[pid].name_user
 
-        name = pids[pid].name_user
         if ctx.internal and ctx.input.startswith("[{"):
             name = trans("msg.name.system")
         if type(ctx.extra) is dict and "agent_evaluate" in ctx.extra:
             name = trans("msg.name.evaluation")
 
-        debug = append_debug(ctx, pid, "input") if is_debug() else ""
+        debug = ""
+        if self.is_debug():
+            debug = self.append_debug(ctx, pid, "input")
 
-        extra = ""
         extra_style = ""
+        extra = ""
         if ctx.extra is not None and "footer" in ctx.extra:
             extra = ctx.extra["footer"]
             extra_style = "display:block;"
+        html = (
+            f'<div class="msg-box msg-user" id="{msg_id}">'
+            f'<div class="name-header name-user">{name}</div>'
+            f'<div class="msg">'
+            f'{html}'
+            f'<div class="msg-extra" style="{extra_style}">{extra}</div>'
+            f'{debug}'
+            f'</div>'
+            f'</div>'
+        )
 
-        return "".join((
-            f'<div class="msg-box msg-user" id="{msg_id}">',
-            f'<div class="name-header name-user">{name}</div>',
-            '<div class="msg">',
-            html,
-            f'<div class="msg-extra" style="{extra_style}">{extra}</div>',
-            debug,
-            '</div>',
-            '</div>',
-        ))
+        return html
 
     def prepare_node_output(
             self,
@@ -1203,97 +1074,86 @@ class Renderer(BaseRenderer):
         :param next_ctx: next context item
         :return: prepared HTML
         """
-        helpers = self.helpers
-        pre_format = helpers.pre_format_text
-        post_format = helpers.post_format_text
-        format_cmd = helpers.format_cmd_text
-        parser = self.parser
-        append_timestamp = self.append_timestamp
-        append_extra = self.append_extra
-        body = self.body
-        prepare_action_icons = body.prepare_action_icons
-        prepare_tool_extra = body.prepare_tool_extra
-        get_name_header = self.get_name_header
-        is_debug = self.is_debug
-        append_debug = self.append_debug
-        get_or_create_pid = self.get_or_create_pid
-        node_output = self.NODE_OUTPUT
-        trans_expand = trans('action.cmd.expand')
-
-        str_id = str(ctx.id)
-        msg_id = f"msg-bot-{ctx.id}" if ctx is not None else ""
-        cmds_len = len(ctx.cmds)
-        extra_ctx_len = len(ctx.extra_ctx) if ctx.extra_ctx is not None else 0
         is_cmd = (
-                next_ctx is not None
-                and next_ctx.internal
-                and (cmds_len > 0 or extra_ctx_len > 0)
-        )
-
-        pid = get_or_create_pid(meta)
-        html = pre_format(html)
-        html = parser.parse(html)
-        html = append_timestamp(ctx, html, type=node_output)
-        html = post_format(html)
-
-        extra = append_extra(meta, ctx, footer=True, render=False)
-        footer = prepare_action_icons(ctx)
-
-        app_path = self.window.core.config.get_app_path()
-        expand_icon_path = os.path.join(app_path, "data", "icons", "expand.svg")
-        cmd_icon = (
-            f'<img src="file://{expand_icon_path}" width="25" height="25" valign="middle">'
-        )
-        expand_btn = (
-            f"<span class='toggle-cmd-output' onclick='toggleToolOutput({str_id});' "
-            f"title='{trans_expand}' role='button'>{cmd_icon}</span>"
+            next_ctx is not None and
+            next_ctx.internal and
+            (len(ctx.cmds) > 0 or (ctx.extra_ctx is not None and len(ctx.extra_ctx) > 0))
         )
+        pid = self.get_or_create_pid(meta)
+        msg_id = f"msg-bot-{ctx.id}" if ctx is not None else ""
+        html = self.helpers.pre_format_text(html)
+        html = self.parser.parse(html)
+        html = self.append_timestamp(ctx, html, type=self.NODE_OUTPUT)
+        html = self.helpers.post_format_text(html)
+        extra = self.append_extra(meta, ctx, footer=True, render=False)
+        footer = self.body.prepare_action_icons(ctx)
 
         tool_output = ""
+        spinner = ""
         output_class = "display:none"
-        agent_step = (
-                ctx.results is not None
-                and len(ctx.results) > 0
-                and isinstance(ctx.extra, dict)
-                and "agent_step" in ctx.extra
+        cmd_icon = f'<img src="{self._file_prefix}{self._icon_expand}" width="25" height="25" valign="middle">'
+        expand_btn = (
+            f"<span class='toggle-cmd-output' onclick='toggleToolOutput({ctx.id});' title='{trans('action.cmd.expand')}' "
+            f"role='button'>{cmd_icon}</span>"
         )
 
         if is_cmd:
-            if agent_step:
-                tool_output = format_cmd(str(ctx.input))
-                output_class = ""  # show tool output
+            if ctx.results is not None and len(ctx.results) > 0 \
+                    and isinstance(ctx.extra, dict) and "agent_step" in ctx.extra:
+                tool_output = self.helpers.format_cmd_text(str(ctx.input))
+                output_class = ""
             else:
-                tool_output = format_cmd(str(next_ctx.input))
-                output_class = ""  # show tool output
-        elif agent_step:
-            tool_output = format_cmd(str(ctx.input))
-
-        html_tools = "".join((
-            f'<div class="tool-output" style="{output_class}">',
-            expand_btn,
-            '<div class="content" style="display:none">',
-            tool_output,
-            '</div></div>',
-        ))
-
-        tool_extra = prepare_tool_extra(ctx)
-
-        debug = append_debug(ctx, pid, "output") if is_debug() else ""
-        name_header = get_name_header(ctx)
-
-        return "".join((
-            f'<div class="msg-box msg-bot" id="{msg_id}">',
-            name_header,
-            '<div class="msg">',
-            html,
-            f'<div class="msg-tool-extra">{tool_extra}</div>',
-            html_tools,
-            f'<div class="msg-extra">{extra}</div>',
-            footer,
-            debug,
-            '</div>',
-            '</div>',
-        ))
+                tool_output = self.helpers.format_cmd_text(str(next_ctx.input))
+                output_class = ""
+
+        elif ctx.results is not None and len(ctx.results) > 0 \
+                and isinstance(ctx.extra, dict) and "agent_step" in ctx.extra:
+            tool_output = self.helpers.format_cmd_text(str(ctx.input))
+        else:
+            out = (getattr(ctx, "output", "") or "")
+            cmds = getattr(ctx, "cmds", ())
+            if next_ctx is None and (
+                    cmds
+                    or out.startswith(('<tool>{"cmd"', '&lt;tool&gt;{"cmd"'))
+                    or out.rstrip().endswith(('}</tool>', '}&lt;/tool&gt;'))
+            ):
+                spinner_class = "" if ctx.live else "display:none"
+                spinner = (
+                    f'<span class="spinner" style="{spinner_class}">'
+                    f'<img src="{self._file_prefix}{self._icon_sync}" width="30" height="30" '
+                    f'class="loading"></span>'
+                )
+
+        html_tools = (
+                f'<div class="tool-output" style="{output_class}">' +
+                expand_btn +
+                '<div class="content" style="display:none">' +
+                tool_output +
+                '</div></div>'
+        )
+        tool_extra = self.body.prepare_tool_extra(ctx)
+
+        debug = ""
+        if self.is_debug():
+            debug = self.append_debug(ctx, pid, "output")
+
+        name_header = self.get_name_header(ctx)
+        html = (
+                f'<div class="msg-box msg-bot" id="{msg_id}">' +
+                name_header +
+                '<div class="msg">' +
+                f'{html}' +
+                f'{spinner}' +
+                f'<div class="msg-tool-extra">{tool_extra}</div>' +
+                f'{html_tools}' +
+                f'<div class="msg-extra">{extra}</div>' +
+                f'{footer}' +
+                f'{debug}' +
+                '</div>' +
+                '</div>'
+        )
+
+        return html
 
     def get_name_header(self, ctx: CtxItem) -> str:
         """
@@ -1323,11 +1183,7 @@ class Renderer(BaseRenderer):
             avatars_dir = os.path.join(presets_dir, "avatars")
             avatar_path = os.path.join(avatars_dir, preset.ai_avatar)
             if os.path.exists(avatar_path):
-                if self.window.core.platforms.is_windows():
-                    prefix = 'file:///'
-                else:
-                    prefix = 'file://'
-                avatar_html = f"<img src=\"{prefix}{avatar_path}\" class=\"avatar\"> "
+                avatar_html = f"<img src=\"{self._file_prefix}{avatar_path}\" class=\"avatar\"> "
 
         if not output_name and not avatar_html:
             return ""
@@ -1348,13 +1204,12 @@ class Renderer(BaseRenderer):
         try:
             node = self.get_output_node_by_pid(pid)
             node.page().runJavaScript(f"if (typeof window.appendNode !== 'undefined') appendNode({escaped_html});")
-            node.update_current_content()
         except Exception as e:
             pass
 
     def reload(self):
         """Reload output, called externally only on theme change to redraw content"""
-        self.window.controller.ctx.refresh_output()  # if clear all and appends all items again
+        self.window.controller.ctx.refresh_output()
 
     def flush(
             self,
@@ -1367,11 +1222,12 @@ class Renderer(BaseRenderer):
         :param pid: context PID
         """
         if self.pids[pid].loaded:
-            return  # wait for page load
+            return
 
         html = self.body.get_html(pid)
-        self.pids[pid].document = html
-        self.get_output_node_by_pid(pid).setHtml(html, baseUrl="file://")
+        node = self.get_output_node_by_pid(pid)
+        if node is not None:
+            node.setHtml(html, baseUrl="file://")
 
     def fresh(
             self,
@@ -1385,14 +1241,16 @@ class Renderer(BaseRenderer):
         pid = self.get_or_create_pid(meta)
         if pid is None:
             return
-        p = self.pids[pid]
         html = self.body.get_html(pid)
-        p.clear(all=True)
-        p.loaded = False
-        p.document = html
+        self.pids[pid].loaded = False
         node = self.get_output_node_by_pid(pid)
-        node.resetPage()
-        node.setHtml(html, baseUrl="file://")
+        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://")
 
     def get_output_node(
             self,
@@ -1426,23 +1284,6 @@ class Renderer(BaseRenderer):
         """
         return self.window.ui.nodes['input']
 
-    def get_document(
-            self,
-            plain: bool = False
-    ):
-        """
-        Get document content (plain or HTML)
-
-        :param plain: True to convert to plain text
-        :return: document content
-        """
-        pid = self.window.core.ctx.container.get_active_pid()
-        if pid is None:
-            return ""
-        if plain:
-            return self.parser.to_plain_text(self.pids[pid].document.replace("<br>", "\n"))
-        return self.pids[pid].document
-
     def remove_item(self, ctx: CtxItem):
         """
         Remove item from output
@@ -1450,7 +1291,9 @@ class Renderer(BaseRenderer):
         :param ctx: context item
         """
         try:
-            self.get_output_node(ctx.meta).page().runJavaScript("if (typeof window.removeNode !== 'undefined') removeNode({});".format(ctx.id))
+            _id = json.dumps(ctx.id)
+            self.get_output_node(ctx.meta).page().runJavaScript(
+                f"if (typeof window.removeNode !== 'undefined') removeNode({_id});")
         except Exception as e:
             pass
 
@@ -1461,7 +1304,9 @@ class Renderer(BaseRenderer):
         :param ctx: context item
         """
         try:
-            self.get_output_node(ctx.meta).page().runJavaScript("if (typeof window.removeNodesFromId !== 'undefined') removeNodesFromId({});".format(ctx.id))
+            _id = json.dumps(ctx.id)
+            self.get_output_node(ctx.meta).page().runJavaScript(
+                f"if (typeof window.removeNodesFromId !== 'undefined') removeNodesFromId({_id});")
         except Exception as e:
             pass
 
@@ -1491,7 +1336,6 @@ class Renderer(BaseRenderer):
 
         :param ctx: context item
         """
-        # remove all items from ID
         self.remove_items_from(ctx)
 
     def on_edit_submit(self, ctx: CtxItem):
@@ -1500,7 +1344,6 @@ class Renderer(BaseRenderer):
 
         :param ctx: context item
         """
-        # remove all items from ID
         self.remove_items_from(ctx)
 
     def on_enable_edit(self, live: bool = True):
@@ -1512,7 +1355,8 @@ class Renderer(BaseRenderer):
         if not live:
             return
         try:
-            for node in self.get_all_nodes():
+            nodes = self.get_all_nodes()
+            for node in nodes:
                 node.page().runJavaScript("if (typeof window.enableEditIcons !== 'undefined') enableEditIcons();")
         except Exception as e:
             pass
@@ -1526,7 +1370,8 @@ class Renderer(BaseRenderer):
         if not live:
             return
         try:
-            for node in self.get_all_nodes():
+            nodes = self.get_all_nodes()
+            for node in nodes:
                 node.page().runJavaScript("if (typeof window.disableEditIcons !== 'undefined') disableEditIcons();")
         except Exception as e:
             pass
@@ -1540,7 +1385,8 @@ class Renderer(BaseRenderer):
         if not live:
             return
         try:
-            for node in self.get_all_nodes():
+            nodes = self.get_all_nodes()
+            for node in nodes:
                 node.page().runJavaScript("if (typeof window.enableTimestamp !== 'undefined') enableTimestamp();")
         except Exception as e:
             pass
@@ -1554,7 +1400,8 @@ class Renderer(BaseRenderer):
         if not live:
             return
         try:
-            for node in self.get_all_nodes():
+            nodes = self.get_all_nodes()
+            for node in nodes:
                 node.page().runJavaScript("if (typeof window.disableTimestamp !== 'undefined') disableTimestamp();")
         except Exception as e:
             pass
@@ -1566,7 +1413,7 @@ class Renderer(BaseRenderer):
     ):
         """
         Update names
-        
+
         :param meta: context meta
         :param ctx: context item
         """
@@ -1580,7 +1427,7 @@ class Renderer(BaseRenderer):
 
     def clear_all(self):
         """Clear all"""
-        for pid in self.pids.keys():
+        for pid in self.pids:
             self.clear_chunks(pid)
             self.clear_nodes(pid)
             self.pids[pid].html = ""
@@ -1614,15 +1461,18 @@ class Renderer(BaseRenderer):
     def reload_css(self):
         """Reload CSS - all, global"""
         to_json = json.dumps(self.body.prepare_styles())
-        for pid in self.pids.keys():
+        nodes = self.get_all_nodes()
+        for pid in self.pids:
             if self.pids[pid].loaded:
-                for node in self.get_all_nodes():
+                for node in nodes:
                     try:
-                        node.page().runJavaScript("if (typeof window.updateCSS !== 'undefined') updateCSS({});".format(to_json))
+                        node.page().runJavaScript(
+                            f"if (typeof window.updateCSS !== 'undefined') updateCSS({to_json});")
                         if self.window.core.config.get('render.blocks'):
                             node.page().runJavaScript("if (typeof window.enableBlocks !== 'undefined') enableBlocks();")
                         else:
-                            node.page().runJavaScript("if (typeof window.disableBlocks !== 'undefined') disableBlocks();")  # TODO: ctx!!!!!
+                            node.page().runJavaScript(
+                                "if (typeof window.disableBlocks !== 'undefined') disableBlocks();")
                     except Exception as e:
                         pass
                 return
@@ -1630,7 +1480,7 @@ class Renderer(BaseRenderer):
     def on_theme_change(self):
         """On theme change"""
         self.window.controller.theme.markdown.load()
-        for pid in self.pids.keys():
+        for pid in self.pids:
             if self.pids[pid].loaded:
                 self.reload_css()
                 return
@@ -1648,7 +1498,8 @@ class Renderer(BaseRenderer):
         """
         escaped_content = json.dumps(content)
         try:
-            self.get_output_node(meta).page().runJavaScript(f"if (typeof window.appendToolOutput !== 'undefined') appendToolOutput({escaped_content});")
+            self.get_output_node(meta).page().runJavaScript(
+                f"if (typeof window.appendToolOutput !== 'undefined') appendToolOutput({escaped_content});")
         except Exception as e:
             pass
 
@@ -1665,7 +1516,8 @@ class Renderer(BaseRenderer):
         """
         escaped_content = json.dumps(content)
         try:
-            self.get_output_node(meta).page().runJavaScript(f"if (typeof window.updateToolOutput !== 'undefined') updateToolOutput({escaped_content});")
+            self.get_output_node(meta).page().runJavaScript(
+                f"if (typeof window.updateToolOutput !== 'undefined') updateToolOutput({escaped_content});")
         except Exception as e:
             pass
 
@@ -1676,7 +1528,8 @@ class Renderer(BaseRenderer):
         :param meta: context meta
         """
         try:
-            self.get_output_node(meta).page().runJavaScript(f"if (typeof window.clearToolOutput !== 'undefined') clearToolOutput();")
+            self.get_output_node(meta).page().runJavaScript(
+                f"if (typeof window.clearToolOutput !== 'undefined') clearToolOutput();")
         except Exception as e:
             pass
 
@@ -1687,14 +1540,16 @@ class Renderer(BaseRenderer):
         :param meta: context meta
         """
         try:
-            self.get_output_node(meta).page().runJavaScript(f"if (typeof window.beginToolOutput !== 'undefined') beginToolOutput();")
+            self.get_output_node(meta).page().runJavaScript(
+                f"if (typeof window.beginToolOutput !== 'undefined') beginToolOutput();")
         except Exception as e:
             pass
 
     def tool_output_end(self):
         """End tool output"""
         try:
-            self.get_output_node().page().runJavaScript(f"if (typeof window.endToolOutput !== 'undefined') endToolOutput();")
+            self.get_output_node().page().runJavaScript(
+                f"if (typeof window.endToolOutput !== 'undefined') endToolOutput();")
         except Exception as e:
             pass
 
@@ -1713,7 +1568,8 @@ class Renderer(BaseRenderer):
         """
         if title is None:
             title = "debug"
-        return f"<div class='debug'><b>{title}:</b> pid: {pid}, ctx: {html.escape(ctx.to_debug())}</div>"
+        debug = "<b>" + title + ":</b> pid: " + str(pid) + ", ctx: " + str(ctx.to_dict())
+        return "<div class='debug'>" + debug + "</div>"
 
     def is_debug(self) -> bool:
         """
@@ -1728,4 +1584,4 @@ class Renderer(BaseRenderer):
         Remove PID from renderer
         """
         if pid in self.pids:
-            del self.pids[pid]
+            del self.pids[pid]