pygpt-net 2.6.19.post1__py3-none-any.whl → 2.6.21__py3-none-any.whl

pygpt_net/controller/chat/response.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.19 07:00:00                  #
+# Updated Date: 2025.08.24 02:00:00                  #
 # ================================================== #
 
 from typing import Dict, Any
@@ -25,6 +25,9 @@ from pygpt_net.utils import trans
 
 
 class Response:
+
+    AGENT_MODES_ALLOWED = (MODE_AGENT_LLAMA, MODE_AGENT_OPENAI)
+
     def __init__(self, window=None):
         """
         Response controller
@@ -47,12 +50,14 @@ class Response:
         :param context: BridgeContext
         :param extra: Extra data
         """
+        core = self.window.core
+        controller = self.window.controller
+        dispatch = self.window.dispatch
         ctx = context.ctx
+
         if not status:
-            error = None
-            if "error" in extra:
-                error = extra.get("error")
-            self.window.controller.chat.log("Bridge response: ERROR")
+            error = extra.get("error", None)
+            controller.chat.log("Bridge response: ERROR")
             if error is not None:
                 self.window.ui.dialogs.alert(error)
                 self.window.update_status(error)
@@ -60,8 +65,8 @@ class Response:
                 self.window.ui.dialogs.alert(trans('status.error'))
                 self.window.update_status(trans('status.error'))
         else:
-            self.window.controller.chat.log_ctx(ctx, "output")  # log
-            if self.window.controller.kernel.stopped():
+            controller.chat.log_ctx(ctx, "output")  # log
+            if controller.kernel.stopped():
                 return
 
         ctx.current = False  # reset current state
@@ -69,19 +74,16 @@ class Response:
         mode = extra.get('mode', MODE_CHAT)
         reply = extra.get('reply', False)
         internal = extra.get('internal', False)
-        self.window.core.ctx.update_item(ctx)
+        core.ctx.update_item(ctx)
 
         # fix frozen chat
         if not status:
-            data = {
+            dispatch(RenderEvent(RenderEvent.TOOL_CLEAR, {
                 "meta": ctx.meta,
-            }
-            event = RenderEvent(RenderEvent.TOOL_CLEAR, data)
-            self.window.dispatch(event)  # hide cmd waiting
-            if not self.window.controller.kernel.stopped():
-                self.window.controller.chat.common.unlock_input()  # unlock input
-            # set state to: error
-            self.window.dispatch(KernelEvent(KernelEvent.STATE_ERROR, {
+            }))  # hide cmd waiting
+            if not controller.kernel.stopped():
+                controller.chat.common.unlock_input()  # unlock input
+            dispatch(KernelEvent(KernelEvent.STATE_ERROR, {
                 "id": "chat",
             }))
             return
@@ -89,7 +91,7 @@ class Response:
         try:
             if mode != MODE_ASSISTANT:
                 ctx.from_previous()  # append previous result if exists
-                self.window.controller.chat.output.handle(
+                controller.chat.output.handle(
                     ctx,
                     mode,
                     stream,
@@ -104,7 +106,7 @@ class Response:
             self.failed(context, extra)
 
         if stream: 
-            if mode not in self.window.controller.chat.output.not_stream_modes:
+            if mode not in controller.chat.output.NOT_STREAM_MODES:
                 return # handled in stream:handleEnd()
 
         # post-handle, execute cmd, etc.
@@ -113,7 +115,7 @@ class Response:
             mode=mode,
             stream=stream,
             reply=reply,
-            internal=internal
+            internal=internal,
         )
 
     def post_handle(
@@ -133,8 +135,9 @@ class Response:
         :param reply: True if reply mode
         :param internal: True if internal mode
         """
-        self.window.controller.chat.output.post_handle(ctx, mode, stream, reply, internal)
-        self.window.controller.chat.output.handle_end(ctx, mode)  # handle end.
+        output = self.window.controller.chat.output
+        output.post_handle(ctx, mode, stream, reply, internal)
+        output.handle_end(ctx, mode)  # handle end.
 
     def begin(
             self,
@@ -163,47 +166,46 @@ class Response:
         :param context: BridgeContext
         :param extra: Extra data
         """
-        global_mode = self.window.core.config.get('mode', MODE_AGENT_LLAMA)
+        core = self.window.core
+        controller = self.window.controller
+        log = controller.chat.log
+        chat_output = controller.chat.output
+        dispatch = self.window.dispatch
+        global_mode = core.config.get("mode", MODE_AGENT_LLAMA)
         ctx = context.ctx
-        if self.window.controller.kernel.stopped():
+
+        # if stopped
+        if controller.kernel.stopped():
             output = ctx.output
             if output and has_unclosed_code_tag(output):
                 ctx.output += "\n```"
             ctx.msg_id = None
             if ctx.id is None:
-                self.window.core.ctx.add(ctx)  # store context to prevent current output from being lost
-                self.window.controller.ctx.prepare_name(ctx)  # summarize if not yet
-
-            # finish render
-            self.window.dispatch(AppEvent(AppEvent.CTX_END))  # app event
-            self.window.dispatch(RenderEvent(RenderEvent.RELOAD))  # reload chat window
+                if not ctx.is_empty():
+                    core.ctx.add(ctx)  # store context to prevent current output from being lost
+                controller.ctx.prepare_name(ctx)  # summarize if not yet
+            dispatch(AppEvent(AppEvent.CTX_END))  # finish render
+            dispatch(RenderEvent(RenderEvent.RELOAD))  # reload chat window
             return
 
-        # at first, handle previous context (user input) if not handled yet
         prev_ctx = ctx.prev_ctx
-        stream = False
         if prev_ctx and prev_ctx.current:
             prev_ctx.current = False  # reset previous context
-            self.window.core.ctx.update_item(prev_ctx)
+            core.ctx.update_item(prev_ctx)
             prev_ctx.from_previous()  # append previous result if exists
-            self.window.controller.chat.output.handle(
+            controller.chat.output.handle(
                 ctx=prev_ctx,
                 mode=prev_ctx.mode,
-                stream_mode=False,
+                stream=False,
             )
-            self.window.controller.chat.output.post_handle(ctx=prev_ctx,
-                                                           mode=prev_ctx.mode,
-                                                           stream=False,
-                                                           reply=False,
-                                                           internal=False)
-
-            self.window.controller.chat.output.handle_end(ctx=prev_ctx,
-                                                          mode=prev_ctx.mode)  # end previous context
+            controller.chat.output.post_handle(ctx=prev_ctx, mode=prev_ctx.mode, stream=False, reply=False, internal=False)
+            controller.chat.output.handle_end(ctx=prev_ctx, mode=prev_ctx.mode)  # end previous context
 
+        stream = context.stream
 
         # if next in agent cycle
         if ctx.partial:
-            self.window.dispatch(AppEvent(AppEvent.CTX_END))  # app event
+            dispatch(AppEvent(AppEvent.CTX_END))  # app event
 
         # handle current step
         ctx.current = False  # reset current state
@@ -211,67 +213,65 @@ class Response:
         reply = ctx.reply
         internal = ctx.internal
 
-        self.window.core.ctx.set_last_item(ctx)
-        event = RenderEvent(RenderEvent.BEGIN, {
+        core.ctx.set_last_item(ctx)
+        dispatch(RenderEvent(RenderEvent.BEGIN, {
             "meta": ctx.meta,
             "ctx": ctx,
             "stream": stream,
-        })
-        self.window.dispatch(event)
+        }))
 
         # append step input to chat window
-        event = RenderEvent(RenderEvent.INPUT_APPEND, {
+        dispatch(RenderEvent(RenderEvent.INPUT_APPEND, {
             "meta": ctx.meta,
             "ctx": ctx,
-        })
-        self.window.dispatch(event)
+        }))
 
         # CTX OUTPUT INFO:
         # - ctx.output may be empty here if stream in OpenAI agents
         # - ctx.live_output may be used against output in LlamaIndex agents
         if ctx.id is None:
-            self.window.core.ctx.add(ctx)
-        else:
-            self.window.core.ctx.update_item(ctx)
+            core.ctx.add(ctx)
+
+        core.ctx.update_item(ctx)
 
         # update ctx meta
-        if mode in (MODE_AGENT_LLAMA, MODE_AGENT_OPENAI) and ctx.meta is not None:
-            self.window.core.ctx.replace(ctx.meta)  # update meta in items
-            self.window.core.ctx.save(ctx.meta.id)
+        if mode in self.AGENT_MODES_ALLOWED and ctx.meta:
+            core.ctx.replace(ctx.meta)  # update meta in items
+            core.ctx.save(ctx.meta.id)
 
             # update preset if exists
-            preset = self.window.controller.presets.get_current()
+            preset = controller.presets.get_current()
             if preset is not None:
                 if ctx.meta.assistant is not None:
                     preset.assistant_id = ctx.meta.assistant
-                    self.window.core.presets.update_and_save(preset)
+                    core.presets.update_and_save(preset)
 
         try:
-            self.window.controller.chat.output.handle(ctx, mode, stream)
+            chat_output.handle(ctx, mode, stream)
         except Exception as e:
-            self.window.controller.chat.log(f"Output ERROR: {e}")  # log
-            self.window.controller.chat.handle_error(e)
+            log(f"Output ERROR: {e}")  # log
+            controller.chat.handle_error(e)
             print(f"Error in append text: {e}")
 
         # post-handle, execute cmd, etc.
-        self.window.controller.chat.output.post_handle(ctx, mode, stream, reply, internal)
-        self.window.controller.chat.output.handle_end(ctx, mode)  # handle end.
+        chat_output.post_handle(ctx, mode, stream, reply, internal)
+        chat_output.handle_end(ctx, mode)  # handle end.
+        dispatch(RenderEvent(RenderEvent.RELOAD))
 
-        event = RenderEvent(RenderEvent.RELOAD)
-        self.window.dispatch(event)
+        # ----------- EVALUATE AGENT RESPONSE -----------
 
         # if continue reasoning
-        if global_mode not in (MODE_AGENT_LLAMA, MODE_AGENT_OPENAI):
+        if global_mode not in self.AGENT_MODES_ALLOWED:
             return  # no agent mode, nothing to do
 
         # not agent final response
         if ctx.extra is None or (isinstance(ctx.extra, dict) and "agent_finish" not in ctx.extra):
             self.window.update_status(trans("status.agent.reasoning"))
-            self.window.controller.chat.common.lock_input()  # lock input, re-enable stop button
+            controller.chat.common.lock_input()  # lock input, re-enable stop button
 
         # agent final response
         if ctx.extra is not None and (isinstance(ctx.extra, dict) and "agent_finish" in ctx.extra):
-            self.window.controller.agent.llama.on_finish(ctx)  # evaluate response and continue if needed
+            controller.agent.llama.on_finish(ctx)  # evaluate response and continue if needed
 
     def end(
             self,
@@ -284,14 +284,10 @@ class Response:
         :param context: BridgeContext
         :param extra: Extra data
         """
-        msg = extra.get("msg", "")
-        status = trans("status.finished")
-        if msg:
-            status = msg
+        status = extra.get("msg", trans("status.finished"))
         self.window.update_status(status)
         self.window.controller.agent.llama.on_end()
         self.window.controller.chat.common.unlock_input()  # unlock input
-        # set state to: idle
         self.window.dispatch(KernelEvent(KernelEvent.STATE_IDLE, {
             "id": "chat",
         }))
@@ -307,44 +303,32 @@ class Response:
         :param context: BridgeContext
         :param extra: Extra data
         """
-        err = extra.get("error") if "error" in extra else None
-        self.window.controller.chat.log(f"Output ERROR: {err}")  # log
-        self.window.controller.chat.handle_error(err)
+        msg = extra.get("error") if "error" in extra else None
+        self.window.controller.chat.log(f"Output ERROR: {msg}")  # log
+        self.window.controller.chat.handle_error(msg)
         self.window.controller.chat.common.unlock_input()  # unlock input
-        print(f"Error in sending text: {err}")
-        # set state to: error
+        print(f"Error in sending text: {msg}")
         self.window.dispatch(KernelEvent(KernelEvent.STATE_ERROR, {
             "id": "chat",
         }))
 
-    def update_status(
+    def live_append(
             self,
             context: BridgeContext,
             extra: Dict[str, Any]
     ):
         """
-        Handle Bridge evaluate
+        Handle Bridge live append
 
         :param context: BridgeContext
         :param extra: Extra data
         """
-        msg = extra.get("msg", "")
-        self.window.update_status(msg)
-
-    def live_append(
-            self,
-            context: BridgeContext,
-            extra: Dict[str, Any]
-    ):
-        ctx = context.ctx
-        data = {
-            "meta": ctx.meta,
-            "ctx": ctx,
+        self.window.dispatch(RenderEvent(RenderEvent.LIVE_APPEND, {
+            "meta": context.ctx.meta,
+            "ctx": context.ctx,
             "chunk": extra.get("chunk", ""),
             "begin": extra.get("begin", False),
-        }
-        event = RenderEvent(RenderEvent.LIVE_APPEND, data)
-        self.window.dispatch(event)
+        }))
 
     def live_clear(
             self,
@@ -357,10 +341,7 @@ class Response:
         :param context: BridgeContext
         :param extra: Extra data
         """
-        ctx = context.ctx
-        data = {
-            "meta": ctx.meta,
-            "ctx": ctx,
-        }
-        event = RenderEvent(RenderEvent.LIVE_CLEAR, data)
-        self.window.dispatch(event)
+        self.window.dispatch(RenderEvent(RenderEvent.LIVE_CLEAR, {
+            "meta": context.ctx.meta,
+            "ctx": context.ctx,
+        }))