pygpt-net 2.5.95__py3-none-any.whl → 2.5.97__py3-none-any.whl

pygpt_net/controller/chat/stream.py

@@ -6,14 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.05 00:00:00                  #
+# Updated Date: 2025.08.11 00:00:00                  #
 # ================================================== #
 
 import base64
-import json
 from typing import Optional
 
-from PySide6.QtCore import QObject, Signal, Slot, QRunnable
+from PySide6.QtCore import QObject, Signal, Slot, QRunnable, QMetaObject, Qt
 
 from pygpt_net.core.bridge import BridgeContext
 from pygpt_net.core.events import RenderEvent
@@ -21,82 +20,95 @@ from pygpt_net.core.types import MODE_ASSISTANT
 from pygpt_net.core.text.utils import has_unclosed_code_tag
 from pygpt_net.item.ctx import CtxItem
 
-
-class StreamWorker(QObject, QRunnable):
+class WorkerSignals(QObject):
+    """
+    Defines the signals available from a running worker thread.
+    - `finished`: No data
+    - `errorOccurred`: Exception
+    - `eventReady`: RenderEvent
+    """
     end = Signal(object)
     errorOccurred = Signal(Exception)
     eventReady = Signal(object)
 
+
+class StreamWorker(QRunnable):
     def __init__(self, ctx: CtxItem, window, parent=None):
-        QObject.__init__(self)
         QRunnable.__init__(self)
+        self.signals = WorkerSignals()
         self.ctx = ctx
         self.window = window
 
     @Slot()
     def run(self):
-        output = ""
+        ctx = self.ctx
+        win = self.window
+        core = win.core
+        ctrl = win.controller
+
+        emit_event = self.signals.eventReady.emit
+        emit_error = self.signals.errorOccurred.emit
+        emit_end = self.signals.end.emit
+
+        output_parts = []
         output_tokens = 0
         begin = True
         error = None
         fn_args_buffers = {}
         citations = []
         files = []
-        img_path = self.window.core.image.gen_unique_path(self.ctx)
+        img_path = core.image.gen_unique_path(ctx)
         is_image = False
         is_code = False
         force_func_call = False
         stopped = False
         chunk_type = "raw"
-        response = None
-        generator = self.ctx.stream
-        self.ctx.stream = None
-        data = {
-            "meta": self.ctx.meta,
-            "ctx": self.ctx
+        generator = ctx.stream
+        ctx.stream = None
+
+        base_data = {
+            "meta": ctx.meta,
+            "ctx": ctx,
         }
-        event = RenderEvent(RenderEvent.STREAM_BEGIN, data)
-        self.eventReady.emit(event)
+        emit_event(RenderEvent(RenderEvent.STREAM_BEGIN, base_data))
 
+        tool_calls = []
         try:
             if generator is not None:
-                tool_calls = []
                 for chunk in generator:
-                    # if force stop then break
-                    if self.window.controller.kernel.stopped():
-                        self.ctx.msg_id = None  # reset message ID
+                    if ctrl.kernel.stopped():
+                        ctx.msg_id = None
                         stopped = True
                         break
+
                     if error is not None:
-                        self.ctx.msg_id = None  # reset message ID
+                        ctx.msg_id = None
                         stopped = True
                         break
 
                     etype = None
                     response = None
 
-                    if self.ctx.use_responses_api:
-                        if hasattr(chunk, 'type'):  # streaming event type
+                    if ctx.use_responses_api:
+                        if hasattr(chunk, 'type'):
                             etype = chunk.type
-                            chunk_type = "api_chat_responses"  # responses API
+                            chunk_type = "api_chat_responses"
                         else:
                             continue
                     else:
                         if (hasattr(chunk, 'choices')
-                                and chunk.choices[0] is not None
+                                and chunk.choices
                                 and hasattr(chunk.choices[0], 'delta')
                                 and chunk.choices[0].delta is not None):
-                            chunk_type = "api_chat"  # chat completions API
+                            chunk_type = "api_chat"
                         elif (hasattr(chunk, 'choices')
-                              and chunk.choices[0] is not None
+                              and chunk.choices
                               and hasattr(chunk.choices[0], 'text')
                               and chunk.choices[0].text is not None):
                             chunk_type = "api_completion"
-                        elif (hasattr(chunk, 'content')
-                              and chunk.content is not None):
+                        elif hasattr(chunk, 'content') and chunk.content is not None:
                             chunk_type = "langchain_chat"
-                        elif (hasattr(chunk, 'delta')
-                              and chunk.delta is not None):
+                        elif hasattr(chunk, 'delta') and chunk.delta is not None:
                             chunk_type = "llama_chat"
                         else:
                             chunk_type = "raw"
@@ -104,16 +116,15 @@ class StreamWorker(QObject, QRunnable):
                     # OpenAI chat completion
                     if chunk_type == "api_chat":
                         citations = None
-                        if chunk.choices[0].delta and chunk.choices[0].delta.content is not None:
-                            if citations is None:
-                                if chunk and hasattr(chunk, 'citations') and chunk.citations is not None:
-                                    citations = chunk.citations
-                                    self.ctx.urls = citations
-                            response = chunk.choices[0].delta.content
-
-                        if chunk.choices[0].delta and chunk.choices[0].delta.tool_calls:
-                            tool_chunks = chunk.choices[0].delta.tool_calls
-                            for tool_chunk in tool_chunks:
+                        delta = chunk.choices[0].delta
+                        if delta and delta.content is not None:
+                            if citations is None and hasattr(chunk, 'citations') and chunk.citations is not None:
+                                citations = chunk.citations
+                                ctx.urls = citations
+                            response = delta.content
+
+                        if delta and delta.tool_calls:
+                            for tool_chunk in delta.tool_calls:
                                 if tool_chunk.index is None:
                                     tool_chunk.index = 0
                                 if len(tool_calls) <= tool_chunk.index:
@@ -121,30 +132,23 @@ class StreamWorker(QObject, QRunnable):
                                         {
                                             "id": "",
                                             "type": "function",
-                                            "function": {
-                                                "name": "",
-                                                "arguments": ""
-                                            }
+                                            "function": {"name": "", "arguments": ""}
                                         }
                                     )
                                 tool_call = tool_calls[tool_chunk.index]
-                                if tool_chunk.id:
+                                if getattr(tool_chunk, "id", None):
                                     tool_call["id"] += tool_chunk.id
-                                if tool_chunk.function.name:
+                                if getattr(tool_chunk.function, "name", None):
                                     tool_call["function"]["name"] += tool_chunk.function.name
-                                if tool_chunk.function.arguments:
+                                if getattr(tool_chunk.function, "arguments", None):
                                     tool_call["function"]["arguments"] += tool_chunk.function.arguments
 
                     # OpenAI Responses API
                     elif chunk_type == "api_chat_responses":
                         if etype == "response.completed":
-                            # MCP tools
                             for item in chunk.response.output:
-                                # MCP: list tools
                                 if item.type == "mcp_list_tools":
-                                    tools = item.tools
-                                    self.window.core.gpt.responses.mcp_tools = tools  # store MCP tools for later use
-                                # MCP: tool call
+                                    core.gpt.responses.mcp_tools = item.tools
                                 elif item.type == "mcp_call":
                                     call = {
                                         "id": item.id,
@@ -160,14 +164,10 @@ class StreamWorker(QObject, QRunnable):
                                         "id": item.id,
                                         "call_id": "",
                                         "type": "function",
-                                        "function": {
-                                            "name": item.name,
-                                            "arguments": item.arguments
-                                        }
+                                        "function": {"name": item.name, "arguments": item.arguments}
                                     })
-                                    self.ctx.extra["mcp_call"] = call
-                                    self.window.core.ctx.update_item(self.ctx)
-                                # MCP: approval request
+                                    ctx.extra["mcp_call"] = call
+                                    core.ctx.update_item(ctx)
                                 elif item.type == "mcp_approval_request":
                                     call = {
                                         "id": item.id,
@@ -176,61 +176,56 @@ class StreamWorker(QObject, QRunnable):
                                         "name": item.name,
                                         "server_label": item.server_label,
                                     }
-                                    self.ctx.extra["mcp_approval_request"] = call
-                                    self.window.core.ctx.update_item(self.ctx)
+                                    ctx.extra["mcp_approval_request"] = call
+                                    core.ctx.update_item(ctx)
 
-                        # text chunk
                         elif etype == "response.output_text.delta":
                             response = chunk.delta
 
-                        # ---------- function_call ----------
+                        # function_call
                         elif etype == "response.output_item.added" and chunk.item.type == "function_call":
                             tool_calls.append({
                                 "id": chunk.item.id,
                                 "call_id": chunk.item.call_id,
                                 "type": "function",
-                                "function": {
-                                    "name": chunk.item.name,
-                                    "arguments": ""
-                                }
+                                "function": {"name": chunk.item.name, "arguments": ""}
                             })
                             fn_args_buffers[chunk.item.id] = ""
                         elif etype == "response.function_call_arguments.delta":
                             fn_args_buffers[chunk.item_id] += chunk.delta
                         elif etype == "response.function_call_arguments.done":
-                            for tc in tool_calls:
-                                if tc["id"] == chunk.item_id:
-                                    tc["function"]["arguments"] = fn_args_buffers[chunk.item_id]
-                                    break
-                            fn_args_buffers.pop(chunk.item_id, None)
-
-                        # ---------- annotations ----------
+                            buf = fn_args_buffers.pop(chunk.item_id, None)
+                            if buf is not None:
+                                for tc in tool_calls:
+                                    if tc["id"] == chunk.item_id:
+                                        tc["function"]["arguments"] = buf
+                                        break
+
+                        # annotations
                         elif etype == "response.output_text.annotation.added":
-                            if chunk.annotation['type'] == "url_citation":
+                            ann = chunk.annotation
+                            if ann['type'] == "url_citation":
                                 if citations is None:
                                     citations = []
-                                url_citation = chunk.annotation['url']
+                                url_citation = ann['url']
                                 citations.append(url_citation)
-                                self.ctx.urls = citations
-                            if chunk.annotation['type'] == "container_file_citation":
-                                container_id = chunk.annotation['container_id']
-                                file_id = chunk.annotation['file_id']
+                                ctx.urls = citations
+                            elif ann['type'] == "container_file_citation":
                                 files.append({
-                                    "container_id": container_id,
-                                    "file_id": file_id,
+                                    "container_id": ann['container_id'],
+                                    "file_id": ann['file_id'],
                                 })
 
-                        # ---------- computer use ----------
+                        # computer use
                         elif etype == "response.reasoning_summary_text.delta":
                             response = chunk.delta
 
                         elif etype == "response.output_item.done":
-                           tool_calls, has_calls = self.window.core.gpt.computer.handle_stream_chunk(self.ctx, chunk, tool_calls)
-                           if has_calls:
-                               force_func_call = True  # force function call if computer use found
+                            tool_calls, has_calls = core.gpt.computer.handle_stream_chunk(ctx, chunk, tool_calls)
+                            if has_calls:
+                                force_func_call = True
 
-
-                        # ---------- code interpreter ----------
+                        # code interpreter
                         elif etype == "response.code_interpreter_call_code.delta":
                             if not is_code:
                                 response = "\n\n**Code interpreter**\n```python\n" + chunk.delta
@@ -240,27 +235,29 @@ class StreamWorker(QObject, QRunnable):
                         elif etype == "response.code_interpreter_call_code.done":
                             response = "\n\n```\n-----------\n"
 
-                        # ---------- image gen ----------
+                        # image gen
                         elif etype == "response.image_generation_call.partial_image":
                             image_base64 = chunk.partial_image_b64
                             image_bytes = base64.b64decode(image_base64)
+                            # prosty i bezpieczny overwrite (jak w oryginale)
                             with open(img_path, "wb") as f:
                                 f.write(image_bytes)
                             is_image = True
 
-                        # ---------- response ID ----------
+                        # response ID
                         elif etype == "response.created":
-                            self.ctx.msg_id = str(chunk.response.id)
-                            self.window.core.ctx.update_item(self.ctx)  # prevent non-existing response ID
+                            ctx.msg_id = str(chunk.response.id)
+                            core.ctx.update_item(ctx)
 
-                        # ---------- end / error ----------
+                        # end/error etype – nic nie robimy
                         elif etype in {"response.done", "response.failed", "error"}:
                             pass
 
                     # OpenAI completion
                     elif chunk_type == "api_completion":
-                        if chunk.choices[0].text is not None:
-                            response = chunk.choices[0].text
+                        choice0 = chunk.choices[0]
+                        if choice0.text is not None:
+                            response = choice0.text
 
                     # langchain chat
                     elif chunk_type == "langchain_chat":
@@ -271,121 +268,115 @@ class StreamWorker(QObject, QRunnable):
                     elif chunk_type == "llama_chat":
                         if chunk.delta is not None:
                             response = str(chunk.delta)
-                        tool_chunks = chunk.message.additional_kwargs.get("tool_calls", [])
+                        tool_chunks = getattr(chunk.message, "additional_kwargs", {}).get("tool_calls", [])
                         if tool_chunks:
                             for tool_chunk in tool_chunks:
-                                id_val = None
-                                name = None
-                                args = {}
-                                if hasattr(tool_chunk, 'arguments'):
-                                    args = tool_chunk.arguments
-                                elif hasattr(tool_chunk, 'function') and hasattr(tool_chunk.function, 'arguments'):
-                                    args = tool_chunk.function.arguments
-                                if hasattr(tool_chunk, 'call_id'):
-                                    id_val = tool_chunk.call_id
-                                elif hasattr(tool_chunk, 'id'):
-                                    id_val = tool_chunk.id
-                                if hasattr(tool_chunk, 'name'):
-                                    name = tool_chunk.name
-                                elif hasattr(tool_chunk, 'function') and hasattr(tool_chunk.function, 'name'):
-                                    name = tool_chunk.function.name
+                                id_val = getattr(tool_chunk, "call_id", None) or getattr(tool_chunk, "id", None)
+                                name = getattr(tool_chunk, "name", None) or getattr(getattr(tool_chunk, "function", None), "name", None)
+                                args = getattr(tool_chunk, "arguments", None)
+                                if args is None:
+                                    f = getattr(tool_chunk, "function", None)
+                                    args = getattr(f, "arguments", None) if f else None
                                 if id_val:
                                     if not args:
-                                        args = "{}"  # JSON encoded
+                                        args = "{}"
                                     tool_call = {
                                         "id": id_val,
                                         "type": "function",
-                                        "function": {
-                                            "name": name,
-                                            "arguments": args
-                                        }
+                                        "function": {"name": name, "arguments": args}
                                     }
                                     tool_calls.clear()
                                     tool_calls.append(tool_call)
 
-                    # raw text: llama-index and langchain completion
+                    # raw text (llama-index / langchain completion)
                     else:
                         if chunk is not None:
                             response = str(chunk)
 
                     if response is not None and response != "" and not stopped:
-                        if begin and response == "":  # prevent empty beginning
+                        if begin and response == "":
                             continue
-                        output += response
+                        output_parts.append(response)
                         output_tokens += 1
-                        data = {
-                            "meta": self.ctx.meta,
-                            "ctx": self.ctx,
-                            "chunk": response,
-                            "begin": begin,
-                        }
-                        event = RenderEvent(RenderEvent.STREAM_APPEND, data)
-                        self.eventReady.emit(event)
+                        emit_event(
+                            RenderEvent(
+                                RenderEvent.STREAM_APPEND,
+                                {
+                                    "meta": ctx.meta,
+                                    "ctx": ctx,
+                                    "chunk": response,
+                                    "begin": begin,
+                                },
+                            )
+                        )
                         begin = False
 
-                # unpack and store tool calls
+                    chunk = None
+
+                # tool calls
                 if tool_calls:
-                    self.ctx.force_call = force_func_call
-                    self.window.core.debug.info("[chat] Tool calls found, unpacking...")
-                    self.window.core.command.unpack_tool_calls_chunks(self.ctx, tool_calls)
+                    ctx.force_call = force_func_call
+                    core.debug.info("[chat] Tool calls found, unpacking...")
+                    core.command.unpack_tool_calls_chunks(ctx, tool_calls)
 
-                # append images
+                # image
                 if is_image:
-                    self.window.core.debug.info("[chat] Image generation call found")
-                    self.ctx.images = [img_path]  # save image path to ctx
+                    core.debug.info("[chat] Image generation call found")
+                    ctx.images = [img_path]
 
         except Exception as e:
             error = e
 
+        finally:
+            output = "".join(output_parts)
+            output_parts.clear()
+
+            if has_unclosed_code_tag(output):
+                output += "\n```"
+
+            if generator and hasattr(generator, 'close'):
+                try:
+                    generator.close()
+                except Exception:
+                    pass
 
-        # fix unclosed code block
-        if has_unclosed_code_tag(output):
-            output += "\n```"
+            del generator
 
-        if generator and hasattr(generator, 'close'):
-            try:
-                generator.close()  # close generator if it has close method
-            except Exception as e:
-                pass
-        del generator
+            ctx.output = output
+            ctx.set_tokens(ctx.input_tokens, output_tokens)
+            core.ctx.update_item(ctx)
 
-        self.ctx.output = output
-        self.ctx.set_tokens(self.ctx.input_tokens, output_tokens)
-        self.window.core.ctx.update_item(self.ctx)  # update ctx
+            if files and not stopped:
+                core.debug.info("[chat] Container files found, downloading...")
+                try:
+                    core.gpt.container.download_files(ctx, files)
+                except Exception as e:
+                    core.debug.error(f"[chat] Error downloading container files: {e}")
 
-        # if files from container are found, download them and append to ctx
-        if files and not stopped:
-            self.window.core.debug.info("[chat] Container files found, downloading...")
-            try:
-                self.window.core.gpt.container.download_files(self.ctx, files)
-            except Exception as e:
-                self.window.core.debug.error(f"[chat] Error downloading container files: {e}")
+            if error:
+                emit_error(error)
 
-        # handle end
-        if error:
-            self.errorOccurred.emit(error)
+            emit_end(ctx)
 
-        self.end.emit(self.ctx)
-        self.cleanup()
+            fn_args_buffers.clear()
+            files.clear()
+            tool_calls.clear()
+            if citations is not None:
+                citations.clear()
+
+            self.cleanup()
 
     def cleanup(self):
+        """
+        Cleanup resources after worker execution.
+        """
+        self.ctx = None
+        self.window = None
         try:
-            self.eventReady.disconnect()
-        except Exception:
-            pass
-        try:
-            self.errorOccurred.disconnect()
-        except Exception:
-            pass
-        try:
-            self.end.disconnect()
+            QMetaObject.invokeMethod(self.signals, "deleteLater", Qt.QueuedConnection)
         except Exception:
             pass
 
-        self.ctx = None
-        self.window = None
-        self.deleteLater()
-
 
 class Stream:
     def __init__(self, window=None):
@@ -417,14 +408,6 @@ class Stream:
     ):
         """
         Asynchronous append of stream worker to the thread.
-
-        :param ctx: CtxItem
-        :param mode: Mode of stream processing
-        :param is_response: Is this a response stream?
-        :param reply: Reply text
-        :param internal: Internal flag for handling
-        :param context: Optional BridgeContext for additional context
-        :param extra: Optional extra data for the stream
         """
         self.ctx = ctx
         self.mode = mode
@@ -435,9 +418,11 @@ class Stream:
         self.extra = extra if extra is not None else {}
 
         worker = StreamWorker(ctx, self.window)
-        worker.eventReady.connect(self.handleEvent)
-        worker.errorOccurred.connect(self.handleError)
-        worker.end.connect(self.handleEnd)
+        self.worker = worker
+
+        worker.signals.eventReady.connect(self.handleEvent)
+        worker.signals.errorOccurred.connect(self.handleError)
+        worker.signals.end.connect(self.handleEnd)
 
         self.window.core.debug.info("[chat] Stream begin...")
         self.window.threadpool.start(worker)
@@ -446,10 +431,6 @@ class Stream:
     def handleEnd(self, ctx: CtxItem):
         """
         Slot for handling end of stream
-
-        This method is called when the stream processing is finished.
-
-        :param ctx: CtxItem
         """
         self.window.controller.ui.update_tokens()
 
@@ -462,13 +443,10 @@ class Stream:
             stream=True,
         )
 
-        # finish: assistant thread run
         if self.mode == MODE_ASSISTANT:
             self.window.controller.assistant.threads.handle_output_message_after_stream(ctx)
         else:
-            # finish: KernelEvent.RESPONSE_OK, KernelEvent.RESPONSE_ERROR
             if self.is_response:
-                # post-handle, execute cmd, etc.
                 self.window.controller.chat.response.post_handle(
                     ctx=ctx,
                     mode=self.mode,
@@ -477,27 +455,18 @@ class Stream:
                     internal=self.internal
                 )
 
-    def handleEvent(self, event):
-        """
-        Slot for handling RenderEvent
+        self.worker = None
 
-        :param event: RenderEvent
-        """
+    def handleEvent(self, event):
         self.window.dispatch(event)
 
     def handleError(self, error):
-        """
-        Slot for handling errors
-
-        :param error: Exception
-        """
         self.window.core.debug.log(error)
         if self.is_response:
             if not isinstance(self.extra, dict):
                 self.extra = {}
             self.extra["error"] = error
-            self.window.controller.chat.response.failed(self.context, self.extra) # send error
-            # post-handle, execute cmd, etc.
+            self.window.controller.chat.response.failed(self.context, self.extra)
             self.window.controller.chat.response.post_handle(
                 ctx=self.ctx,
                 mode=self.mode,
@@ -507,9 +476,4 @@ class Stream:
             )
 
     def log(self, data: object):
-        """
-        Save debug log data
-
-        :param data: log data
-        """
         self.window.core.debug.info(data)

pygpt_net/controller/ctx/ctx.py

@@ -6,9 +6,9 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.08 23:00:00                  #
+# Updated Date: 2025.08.11 00:00:00                  #
 # ================================================== #
-import gc
+
 from typing import Optional, List
 
 from PySide6.QtCore import QModelIndex, QTimer
@@ -21,8 +21,7 @@ from .common import Common
 from .summarizer import Summarizer
 from .extra import Extra
 
-from pygpt_net.utils import trans
-from pygpt_net.core.tabs.tab import Tab
+from pygpt_net.utils import trans, mem_clean
 
 
 class Ctx:
@@ -943,11 +942,12 @@ class Ctx:
         :param child_id: int
         :return: QModelIndex
         """
+        finder = self.find_child_index_by_id
         for row in range(root_item.rowCount()):
             item = root_item.child(row)
             if hasattr(item, 'id') and hasattr(item, 'isFolder') and not item.isFolder and item.id == child_id:
                 return item.index()
-            child_index = self.find_child_index_by_id(item, child_id)
+            child_index = finder(item, child_id)
             if child_index.isValid():
                 return child_index
         return QModelIndex()