pygpt-net 2.6.20__py3-none-any.whl → 2.6.22__py3-none-any.whl

pygpt_net/controller/chat/output.py

@@ -6,23 +6,31 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.18 01:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 from typing import Any, Optional
 
 from pygpt_net.core.bridge import BridgeContext
 from pygpt_net.core.types import (
-    MODE_AGENT,
     MODE_ASSISTANT,
     MODE_IMAGE,
 )
 from pygpt_net.core.events import Event, AppEvent, RenderEvent, KernelEvent
 from pygpt_net.item.ctx import CtxItem
-from pygpt_net.utils import mem_clean
 
 
 class Output:
+
+    STATE_PARAMS = {
+        "id": "chat",
+    }
+
+    NOT_STREAM_MODES = (
+        MODE_ASSISTANT,
+        MODE_IMAGE
+    )
+
     def __init__(self, window=None):
         """
         Output controller
@@ -30,16 +38,12 @@ class Output:
         :param window: Window instance
         """
         self.window = window
-        self.not_stream_modes = [
-            MODE_ASSISTANT,
-            MODE_IMAGE,
-        ]
 
     def handle(
             self,
             ctx: CtxItem,
             mode: str,
-            stream_mode: bool = False,
+            stream: bool = False,
             is_response: bool = False,
             reply: bool = False,
             internal: bool = False,
@@ -51,20 +55,20 @@ class Output:
 
         :param ctx: CtxItem
         :param mode: mode (global)
-        :param stream_mode: stream mode
+        :param stream: stream enabled (local)
         :param is_response: Is response output
         :param reply: is reply
         :param internal: is internal command
         :param context: BridgeContext (optional)
         :param extra: Extra data (optional)
         """
-        self.window.stateChanged.emit(self.window.STATE_BUSY)
+        self.window.dispatch(KernelEvent(KernelEvent.STATE_BUSY))  # state: busy
 
-        # if stream mode then append chunk by chunk
+        # if stream then append chunk by chunk
         end = True
-        if stream_mode:  # local stream enabled
-            if mode not in self.not_stream_modes:
-                end = False  # don't end stream mode, append chunk by chunk
+        if stream:  # local, not global config
+            if mode not in self.NOT_STREAM_MODES:
+                end = False  # don't end if stream mode, append chunk by chunk
                 self.window.controller.chat.stream.append(
                     ctx=ctx,
                     mode=mode,
@@ -79,7 +83,7 @@ class Output:
             self.handle_after(
                 ctx=ctx,
                 mode=mode,
-                stream=stream_mode
+                stream=stream,
             )
 
     def handle_after(
@@ -93,59 +97,52 @@ class Output:
 
         :param ctx: CtxItem
         :param mode: mode (global)
-        :param stream: stream mode
+        :param stream: stream enabled (local)
         """
+        core = self.window.core
+        dispatch = self.window.dispatch
+        log = self.window.controller.chat.log
+
         # check if tool calls detected
         if ctx.tool_calls:
             # if not internal commands in a text body then append tool calls as commands (prevent double commands)
-            if not self.window.core.command.has_cmds(ctx.output):
-                self.window.core.command.append_tool_calls(ctx)  # append tool calls as commands
+            if not core.command.has_cmds(ctx.output):
+                core.command.append_tool_calls(ctx)  # append tool calls as commands
                 if not isinstance(ctx.extra, dict):
                     ctx.extra = {}
                 ctx.extra["tool_calls"] = ctx.tool_calls
                 stream = False  # disable stream mode, show tool calls at the end
-                self.log("Tool call received...")
+                log("Tool call received...")
             else:  # prevent execute twice
-                self.log("Ignoring tool call because command received...")
-
-        # agent mode
-        if mode == MODE_AGENT:
-            self.window.controller.agent.legacy.on_ctx_after(ctx)
+                log("Ignoring tool call because command received...")
 
         # event: context after
-        event = Event(Event.CTX_AFTER)
-        event.ctx = ctx
-        self.window.dispatch(event)
+        dispatch(Event(Event.CTX_AFTER, {
+            'mode': mode,
+        }, ctx=ctx))
 
-        self.log("Appending output to chat window...")
+        log("Appending output to chat window...")
 
         # only append output if not in stream mode, TODO: plugin output add
-        stream_enabled = self.window.core.config.get('stream', False)
+        stream_global = core.config.get('stream', False)
         if not stream:
-            if stream_enabled:  # use global stream settings here to persist previously added input
-                data = {
+            if stream_global:  # use global stream settings here to persist previously added input
+                dispatch(RenderEvent(RenderEvent.INPUT_APPEND, {
                     "meta": ctx.meta,
                     "ctx": ctx,
                     "flush": True,
                     "append": True,
-                }
-                event = RenderEvent(RenderEvent.INPUT_APPEND, data)
-                self.window.dispatch(event)
+                }))
 
-            data = {
+            dispatch(RenderEvent(RenderEvent.OUTPUT_APPEND, {
                 "meta": ctx.meta,
                 "ctx": ctx,
-            }
-            event = RenderEvent(RenderEvent.OUTPUT_APPEND, data)
-            self.window.dispatch(event)
-
-            data = {
+            }))
+            dispatch(RenderEvent(RenderEvent.EXTRA_APPEND, {
                 "meta": ctx.meta,
                 "ctx": ctx,
                 "footer": True,
-            }
-            event = RenderEvent(RenderEvent.EXTRA_APPEND, data)
-            self.window.dispatch(event)  # + icons
+            }))  # + icons
 
         self.handle_complete(ctx)
 
@@ -155,29 +152,22 @@ class Output:
 
         :param ctx: CtxItem
         """
-        mode = self.window.core.config.get('mode')
-        self.window.core.ctx.post_update(mode)  # post update context, store last mode, etc.
-        self.window.core.ctx.store()
-        self.window.controller.ctx.update_ctx()  # update current ctx info
-
-        # update response tokens
-        self.window.controller.chat.common.show_response_tokens(ctx)
+        core = self.window.core
+        controller = self.window.controller
+        dispatch = self.window.dispatch
+        mode = core.config.get('mode')
 
-        # handle audio output
-        self.window.controller.chat.audio.handle_output(ctx)
+        # post update context, store last mode, etc.
+        core.ctx.post_update(mode)
+        core.ctx.store()
 
-        # store to history
-        if self.window.core.config.get('store_history'):
-            self.window.core.history.append(ctx, "output")
+        controller.ctx.update_ctx()
+        controller.ctx.store_history(ctx, "output")  # store to history
 
-        if self.window.controller.chat.common.can_unlock(ctx):
-            if not self.window.controller.kernel.stopped():
-                self.window.controller.chat.common.unlock_input()  # unlock input
-
-        # reset state to: idle
-        self.window.dispatch(KernelEvent(KernelEvent.STATE_IDLE, {
-            "id": "chat",
-        }))
+        controller.chat.audio.handle_output(ctx)  # handle audio output
+        controller.chat.common.auto_unlock(ctx)  # unlock input if allowed
+        controller.chat.common.show_response_tokens(ctx)  # update tokens
+        dispatch(KernelEvent(KernelEvent.STATE_IDLE, self.STATE_PARAMS))  # state: idle
 
     def post_handle(
             self,
@@ -196,46 +186,33 @@ class Output:
         :param reply: is reply
         :param internal: is internal
         """
+        core = self.window.core
+        controller = self.window.controller
+        dispatch = self.window.dispatch
+
         # if commands enabled: post-execute commands (not assistant mode)
         if mode != MODE_ASSISTANT:
             ctx.clear_reply()  # reset results
-
-            # extract expert mentions and handle experts reply
-            num_calls = self.window.controller.agent.experts.handle(ctx)
-            if num_calls == 0:
-                # handle commands only if no expert calls in queue
-                self.window.controller.chat.command.handle(ctx)
+            expert_calls = controller.agent.experts.handle(ctx)
+            if expert_calls == 0:  # handle commands only if no expert calls in queue
+                controller.chat.command.handle(ctx)
 
             ctx.from_previous()  # append previous result again before save
-            self.window.core.ctx.update_item(ctx)  # update ctx in DB
+            core.ctx.update_item(ctx)  # update ctx in DB
 
         # render: end
         if ctx.sub_calls == 0:  # if no experts called
-            data = {
+            dispatch(RenderEvent(RenderEvent.END, {
                 "meta": ctx.meta,
                 "ctx": ctx,
                 "stream": stream,
-            }
-            event = RenderEvent(RenderEvent.END, data)
-            self.window.dispatch(event)
-
-        # don't unlock input and leave stop btn if assistant mode or if agent/autonomous is enabled
-        # send btn will be unlocked in agent mode on stop
-        if self.window.controller.chat.common.can_unlock(ctx):
-            if not self.window.controller.kernel.stopped():
-                self.window.controller.chat.common.unlock_input()  # unlock input
-
-        # handle ctx name (generate title from summary if not initialized)
-        if not ctx.meta or not ctx.meta.initialized:  # don't call if reply or internal mode
-            if self.window.core.config.get('ctx.auto_summary'):
-                self.log("Calling for prepare context name...")
-                self.window.controller.ctx.prepare_name(ctx)  # async
+            }))
 
-        if self.window.state != self.window.STATE_ERROR:
-            if mode != MODE_ASSISTANT:
-                self.window.dispatch(KernelEvent(KernelEvent.STATE_IDLE, {
-                    "id": "chat",
-                }))
+        controller.chat.common.auto_unlock(ctx)  # unlock input if allowed
+        controller.ctx.prepare_summary(ctx)  # prepare ctx name
+
+        if self.window.state != self.window.STATE_ERROR and mode != MODE_ASSISTANT:
+            dispatch(KernelEvent(KernelEvent.STATE_IDLE, self.STATE_PARAMS))  # state: idle
 
     def handle_end(
             self,
@@ -248,60 +225,26 @@ class Output:
         :param ctx: CtxItem
         :param mode: mode
         """
-        # clear attachments after send, only if attachments has been provided before send
-        auto_clear = self.window.core.config.get('attachments_send_clear')
-        if self.window.controller.attachment.clear_allowed(ctx):
-            if auto_clear and not self.window.controller.attachment.is_locked():
-                self.window.controller.attachment.clear(force=True, auto=True)
-                self.window.controller.attachment.update()
-                self.log("Attachments cleared.")  # log
-
-        if self.window.core.config.get("log.ctx"):
-            self.log(f"Context: END: {ctx}")
-        else:
-            self.log("Context: END.")
-
-        # agent mode
-        if mode == MODE_AGENT:
-            agent_iterations = int(self.window.core.config.get("agent.iterations"))
-            self.log(f"Agent: ctx end, iterations: {agent_iterations}")
-            self.window.controller.agent.legacy.on_ctx_end(
-                ctx,
-                iterations=agent_iterations,
-            )
+        controller = self.window.controller
+        dispatch = self.window.dispatch
+        log = controller.chat.log
 
-        # event: context end
-        event = Event(Event.CTX_END)
-        event.ctx = ctx
-        self.window.dispatch(event)
-        self.window.controller.ui.update_tokens()  # update UI
-        self.window.controller.chat.input.generating = False  # unlock
+        controller.attachment.cleanup(ctx)  # clear after send
+        log(f"Context: END: {ctx}" if self.window.core.config.get("log.ctx") else "Context: END.")
 
-        if (mode not in self.window.controller.chat.input.no_ctx_idx_modes
-                and not self.window.controller.agent.legacy.enabled()):
-            self.window.controller.idx.on_ctx_end(ctx, mode=mode)  # update ctx DB index
-            # disabled in agent mode here to prevent loops, handled in agent flow internally if agent mode
+        # event: context end
+        dispatch(Event(Event.CTX_END, {
+            'mode': mode,
+        }, ctx=ctx))
+        controller.chat.input.generating = False  # unlock
 
-        self.log("End.")
-        self.window.dispatch(AppEvent(AppEvent.CTX_END))  # app event
+        log("End.")
+        dispatch(AppEvent(AppEvent.CTX_END))  # app event
 
         # restore state to idle if no errors
         if self.window.state != self.window.STATE_ERROR:
-            self.window.stateChanged.emit(self.window.STATE_IDLE)
+            dispatch(KernelEvent(KernelEvent.STATE_IDLE, self.STATE_PARAMS))
 
         if mode != MODE_ASSISTANT:
-            self.window.controller.kernel.stack.handle()  # handle reply
-            event = RenderEvent(RenderEvent.RELOAD)
-            self.window.dispatch(event)  # reload chat window
-
-        mem_clean()
-
-        # self.window.core.debug.mem("END")  # debug memory usage
-
-    def log(self, data: Any):
-        """
-        Log data to debug
-
-        :param data: Data to log
-        """
-        self.window.controller.chat.log(data)
+            controller.kernel.stack.handle()  # handle reply
+            dispatch(RenderEvent(RenderEvent.RELOAD))  # reload chat window