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

pygpt_net/controller/chat/text.py

@@ -6,7 +6,7 @@
 # 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 Optional
@@ -34,7 +34,7 @@ class Text:
         :param window: Window instance
         """
         self.window = window
-        self.ctx_pid = 0
+        self.ctx_pid = 0  # sequence number for context items
 
     def send(
             self,
@@ -42,7 +42,6 @@ class Text:
             reply: bool = False,
             internal: bool = False,
             prev_ctx: Optional[CtxItem] = None,
-            parent_id: Optional[str] = None,
             multimodal_ctx: Optional[MultimodalContext] = None,
     ) -> CtxItem:
         """
@@ -52,59 +51,49 @@ class Text:
         :param reply: reply from plugins
         :param internal: internal call
         :param prev_ctx: previous context item (if reply)
-        :param parent_id: parent context id
         :param multimodal_ctx: multimodal context
-        :return: context item
+        :return: CtxItem instance
         """
-        self.window.update_status(trans('status.sending'))
+        self.window.update_status(trans("status.sending"))
+
+        core = self.window.core
+        controller = self.window.controller
+        dispatch = self.window.dispatch
+        config = core.config
+        log = controller.chat.log
 
         # event: prepare username
         event = Event(Event.USER_NAME, {
-            'value': self.window.core.config.get('user_name'),
+            "value": config.get("user_name"),
         })
-        self.window.dispatch(event)
-        user_name = event.data['value']
+        dispatch(event)
+        user_name = event.data["value"]
 
-        # event: prepare ai.name
+        # event: prepare AI name
         event = Event(Event.AI_NAME, {
-            'value': self.window.core.config.get('ai_name'),
+            "value": config.get("ai_name"),
         })
-        self.window.dispatch(event)
-        ai_name = event.data['value']
+        dispatch(event)
+        ai_name = event.data["value"]
 
         # prepare mode, model, etc.
-        agent_provider = None  # agent provider (llama or openai)
-        mode = self.window.core.config.get('mode')
-        model = self.window.core.config.get('model')
-        model_data = self.window.core.models.get(model)
-        stream_mode = self.window.core.config.get('stream')
-        agent_idx = self.window.core.config.get('agent.llama.idx')
-        sys_prompt = self.window.core.config.get('prompt')
+        mode = config.get("mode")
+        model = config.get("model")
+        model_data = core.models.get(model)
+        sys_prompt = config.get("prompt")
         sys_prompt_raw = sys_prompt  # store raw prompt (without addons)
-        max_tokens = self.window.core.config.get('max_output_tokens')  # max output tokens
-        base_mode = mode  # store parent mode
+        max_tokens = config.get("max_output_tokens")  # max output tokens
+        idx_mode = config.get("llama.idx.mode")
+        base_mode = mode  # store base parent mode
+        stream = self.is_stream(mode)  # check if stream is enabled for given mode
+
         functions = []  # functions to call
         tools_outputs = []  # tools outputs (assistant only)
-        idx_mode = self.window.core.config.get('llama.idx.mode')
-
-        # agent provider
-        if mode == MODE_AGENT_LLAMA:
-            agent_provider = self.window.core.config.get('agent.llama.provider')
-        elif mode == MODE_AGENT_OPENAI:
-            agent_provider = self.window.core.config.get('agent.openai.provider')
-
-        # o1 models: disable stream mode
-        if mode in (MODE_AGENT_LLAMA, MODE_AUDIO):
-            stream_mode = False
-        if mode == MODE_LLAMA_INDEX and idx_mode == "retrieval":
-            stream_mode = False
-        if mode == MODE_LLAMA_INDEX:
-            if not self.window.core.idx.chat.is_stream_allowed():
-                stream_mode = False
 
         # create ctx item
-        meta = self.window.core.ctx.get_current_meta()
-        meta.preset = self.window.core.config.get('preset')  # current preset
+        meta = core.ctx.get_current_meta()
+        meta.preset = config.get("preset")  # current preset
+
         ctx = CtxItem()
         ctx.meta = meta  # CtxMeta (owner object)
         ctx.internal = internal
@@ -116,63 +105,38 @@ class Text:
         ctx.prev_ctx = prev_ctx  # store previous context item if exists
         ctx.live = True
         ctx.pid = self.ctx_pid  # store PID
+
         self.ctx_pid += 1  # increment PID
 
         # if prev ctx is not empty, then copy input name to current ctx
         if prev_ctx is not None and prev_ctx.sub_call is True:  # sub_call = sent from expert
             ctx.input_name = prev_ctx.input_name
-
-        # if reply from expert command
-        if parent_id is not None:  # parent_id = reply from expert
-            # At this point, ctx.meta ID = slave META ID (parent_id is given from slave, not from master)
-            ctx.sub_reply = True  # mark as sub reply
-            ctx.input_name = prev_ctx.input_name
-            ctx.output_name = prev_ctx.output_name
-            ctx.extra["sub_reply"] = True  # mark as sub reply in extra data
-        else:
-            self.window.core.ctx.set_last_item(ctx)  # store last item
-
         if reply:
             ctx.extra["sub_reply"] = True  # mark as sub reply in extra data
 
-        self.window.controller.files.uploaded_ids = []  # clear uploaded files ids at the beginning
+        controller.files.reset()  # clear uploaded files IDs
+        controller.ctx.store_history(ctx, "input")  # store to history
+        controller.chat.log_ctx(ctx, "input")  # log
 
         # assistant: create thread, upload attachments
         if mode == MODE_ASSISTANT:
-            self.window.controller.assistant.begin(ctx)
-
-        # store in history (input only)
-        if self.window.core.config.get('store_history'):
-            self.window.core.history.append(ctx, "input")        
-
-        self.window.controller.chat.log_ctx(ctx, "input")  # log
-
-        # agent mode: before context
-        if mode == MODE_AGENT:
-            self.window.controller.agent.legacy.on_ctx_before(ctx)
-
-        # event: context before
-        event = Event(Event.CTX_BEFORE)
-        event.ctx = ctx
-        self.window.dispatch(event)
+            controller.assistant.begin(ctx)
 
-        # agent or expert mode
-        sys_prompt = self.window.controller.agent.experts.append_prompts(
-            mode,
-            sys_prompt,
-            parent_id
-        )
+        # event: ctx before
+        dispatch(Event(Event.CTX_BEFORE, {
+            "mode": mode,
+        }, ctx=ctx))
 
-        # on pre prompt event
+        # event: on pre prompt
         event = Event(Event.PRE_PROMPT, {
-            'mode': mode,
-            'value': str(sys_prompt),
+            "mode": mode,
+            "value": str(sys_prompt),
         })
-        self.window.dispatch(event)
-        sys_prompt = event.data['value']
+        dispatch(event)
+        sys_prompt = event.data["value"]
 
         # build final prompt (+plugins)
-        sys_prompt = self.window.core.prompt.prepare_sys_prompt(
+        sys_prompt = core.prompt.prepare_sys_prompt(
             mode=mode,
             model=model_data,
             sys_prompt=sys_prompt,
@@ -181,101 +145,104 @@ class Text:
             internal=internal,
         )
 
-        self.window.controller.chat.log("Appending input to chat window...")
+        log("Appending input to chat window...")
 
         # render: begin
-        data = {
+        dispatch(RenderEvent(RenderEvent.BEGIN, {
             "meta": ctx.meta,
             "ctx": ctx,
-            "stream": stream_mode,
-        }
-        event = RenderEvent(RenderEvent.BEGIN, data)
-        self.window.dispatch(event)
-
-        # append text from input to chat window
-        data = {
+            "stream": stream,
+        }))
+        # render: append input text
+        dispatch(RenderEvent(RenderEvent.INPUT_APPEND, {
             "meta": ctx.meta,
             "ctx": ctx,
-        }
-        event = RenderEvent(RenderEvent.INPUT_APPEND, data)
-        self.window.dispatch(event)
+        }))
 
         # add ctx to DB here and only update it after response,
         # MUST BE REMOVED AFTER AS FIRST MSG (LAST ON LIST)
-        self.window.core.ctx.add(ctx, parent_id=parent_id)
+        core.ctx.add(ctx)
+        core.ctx.set_last_item(ctx)  # mark as last item
+        controller.ctx.update(reload=True, all=False)
 
-        # update ctx list, but not reload all to prevent focus out on lists
-        self.window.controller.ctx.update(
-            reload=True,
-            all=False,
-        )
+        # prepare user and plugin tools (native mode only)
+        functions.extend(core.command.get_functions())
 
-        # functions: prepare user and plugins functions (native mode only)
-        functions += self.window.core.command.get_functions(parent_id)
-
-        # assistant only
+        # assistant only - prepare tool outputs for assistant
         if mode == MODE_ASSISTANT:
-            # prepare tool outputs for assistant
-            tools_outputs = self.window.controller.assistant.threads.handle_tool_outputs(ctx)
+            tools_outputs = controller.assistant.threads.handle_tool_outputs(ctx)
             if len(tools_outputs) > 0:
-                self.window.controller.chat.log("Tool outputs sending...")
+                log("Tool outputs sending...")
+
+        # --------------------- BRIDGE CALL ---------------------
 
-        # make API call
         try:
-            # get attachments
-            files = self.window.core.attachments.get_all(mode)
+            files = core.attachments.get_all(mode)  # get attachments
             num_files = len(files)
             if num_files > 0:
-                self.window.controller.chat.log(f"Attachments ({mode}): {num_files}")
-
-            # assistant
-            assistant_id = self.window.core.config.get('assistant')
-            if mode == MODE_AGENT_LLAMA:
-                preset = self.window.controller.presets.get_current()
-                if preset is not None:
-                    assistant_id = preset.assistant_id
-
-            self.window.dispatch(AppEvent(AppEvent.INPUT_CALL))  # app event
-            bridge_context = BridgeContext(
-                ctx=ctx,
-                history=self.window.core.ctx.all(meta_id=parent_id),  # get all ctx items
+                log(f"Attachments ({mode}): {num_files}")
+
+            context = BridgeContext(
+                assistant_id=config.get("assistant"),
+                attachments=files,
+                ctx=ctx, # CtxItem instance
+                external_functions=functions,  # external functions
+                file_ids=controller.files.get_ids(),  # uploaded files IDs
+                history=core.ctx.all(),  # get all ctx items
+                idx=controller.idx.get_current(),  # current idx
+                idx_mode=idx_mode,  # llama index mode (chat or query)
+                max_tokens=max_tokens,  # max output tokens
                 mode=mode,
+                model=model_data, # ModelItem instance
+                multimodal_ctx=multimodal_ctx,  # multimodal context
                 parent_mode=base_mode,
-                model=model_data,
+                preset=controller.presets.get_current(),  # current preset
+                prompt=text,  # input text
+                stream=stream,  # is stream enabled
                 system_prompt=sys_prompt,
                 system_prompt_raw=sys_prompt_raw,  # for llama-index (query mode only)
-                prompt=text,  # input text
-                stream=stream_mode,  # is stream mode
-                attachments=files,
-                file_ids=self.window.controller.files.uploaded_ids,  # uploaded files IDs
-                assistant_id=assistant_id,
-                idx=self.window.controller.idx.current_idx,  # current idx
-                idx_mode=idx_mode,  # llama index mode (chat or query)
-                external_functions=functions,  # external functions
                 tools_outputs=tools_outputs,  # if not empty then will submit outputs to assistant
-                max_tokens=max_tokens,  # max output tokens
-                multimodal_ctx=multimodal_ctx,  # multimodal context
-                preset=self.window.controller.presets.get_current(),  # current preset
             )
             extra = {
-                'mode': mode,
-                'reply': reply,
-                'internal': internal,
+                "mode": mode,
+                "reply": reply,
+                "internal": internal,
             }
-            if mode in (MODE_AGENT_LLAMA, MODE_AGENT_OPENAI):
-                extra['agent_idx'] = agent_idx
-                extra['agent_provider'] = agent_provider
 
-            self.window.controller.chat.common.lock_input()  # lock input
-            event = KernelEvent(KernelEvent.REQUEST, {
-                'context': bridge_context,
-                'extra': extra,
-            })
-            self.window.dispatch(event)
+            # event: bridge before
+            dispatch(Event(Event.BRIDGE_BEFORE, {
+                "mode": mode,
+                "context": context,
+                "extra": extra,
+            }))
+
+            controller.chat.common.lock_input()  # lock input
+            dispatch(AppEvent(AppEvent.INPUT_CALL))  # app event
+            dispatch(KernelEvent(KernelEvent.REQUEST, {
+                "context": context,
+                "extra": extra,
+            }))
 
         except Exception as e:
-            self.window.controller.chat.log(f"Bridge call ERROR: {e}")  # log
-            self.window.controller.chat.handle_error(e)
-            print(f"Error when calling bridge: {e}")
+            controller.chat.handle_error(e)
+            log(f"Bridge call ERROR: {e}")
+
+        return ctx
 
-        return ctx
+    def is_stream(self, mode: str) -> bool:
+        """
+        Check if stream is enabled for given mode
+
+        :param mode: mode
+        :return: True if stream is enabled, False otherwise
+        """
+        core = self.window.core
+        stream = core.config.get("stream")
+        if mode in (MODE_AGENT_LLAMA, MODE_AUDIO):
+            return False  # TODO: check if this is correct in agent
+        elif mode == MODE_LLAMA_INDEX:
+            if core.config.get("llama.idx.mode") == "retrieval":
+                return False
+            if not core.idx.chat.is_stream_allowed():
+                return False
+        return stream

pygpt_net/controller/ctx/common.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.16 00:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 from typing import Optional
@@ -17,6 +17,7 @@ from PySide6.QtWidgets import QApplication
 from pygpt_net.core.tabs.tab import Tab
 from pygpt_net.utils import trans
 from pygpt_net.item.ctx import CtxMeta
+
 from .summarizer import Summarizer
 
 

pygpt_net/controller/ctx/ctx.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.16 00:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 from typing import Optional, List
@@ -14,17 +14,20 @@ from typing import Optional, List
 from PySide6.QtCore import QModelIndex, QTimer
 from PySide6.QtGui import QStandardItem
 
-from pygpt_net.core.events import Event, AppEvent, RenderEvent
 from pygpt_net.item.ctx import CtxItem, CtxMeta
+from pygpt_net.core.types import MODE_ASSISTANT
+from pygpt_net.core.events import (
+    Event,
+    AppEvent,
+    RenderEvent,
+    BaseEvent
+)
+from pygpt_net.utils import trans
 
 from .common import Common
 from .summarizer import Summarizer
 from .extra import Extra
 
-from pygpt_net.utils import trans
-from pygpt_net.core.types import MODE_ASSISTANT
-
-
 class Ctx:
     def __init__(self, window=None):
         """
@@ -45,6 +48,55 @@ class Ctx:
         self.group_id = None
         self.selected = []
 
+    def handle(self, event: BaseEvent):
+        """
+        Handle events
+
+        :param event: BaseEvent: Event to handle
+        """
+        name = event.name
+
+        # on input begin
+        if name == Event.INPUT_BEGIN:
+            force = event.data.get("force", False)
+            stop = event.data.get("stop", False)
+            if not force and not stop:
+                if self.extra.is_editing():
+                    event.data["stop"] = True  # stop flow
+                    self.extra.edit_submit()
+                    return
+
+        # on input before
+        elif name == Event.INPUT_BEFORE:
+            mode = event.data.get("mode")
+            text = event.data.get("value", "")
+            multimodal_ctx = event.data.get("multimodal_ctx", None)
+            # check if image captured from camera and attachment exists
+            camera_captured = (self.window.controller.ui.vision.has_vision()
+                               and self.window.controller.attachment.has(mode))
+
+            # allow empty text input only if multimodal data, otherwise abort
+            is_audio = multimodal_ctx is not None and multimodal_ctx.is_audio_input
+            if len(text.strip()) == 0 and (not camera_captured and not is_audio):
+                event.data["stop"] = True  # stop flow
+                event.data["silent"] = True  # silent stop (no errors)
+                return
+
+        # on input accept
+        elif name == Event.INPUT_ACCEPT:
+            mode = event.data.get("mode")
+            # prepare ctx, create new ctx meta if there is no ctx, or no ctx selected
+            if self.window.core.ctx.count_meta() == 0 or self.window.core.ctx.get_current() is None:
+                self.window.core.ctx.new()
+                self.update()
+                self.window.controller.chat.log("New context created...")  # log
+            else:
+                # check if current ctx is allowed for this mode - if not, then auto-create new ctx
+                self.handle_allowed(mode)
+
+            # update mode in ctx
+            self.update_mode_in_current()
+
     def setup(self):
         """Setup ctx"""
         self.common.restore_display_filter()  # load filters first
@@ -1152,6 +1204,34 @@ class Ctx:
                 self.group_id = None
             self.update_and_restore()
 
+    def prepare_summary(self, ctx: CtxItem) -> bool:
+        """
+        Prepare context summary
+
+        :param ctx: CtxItem
+        :return: True if handled
+        """
+        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.window.controller.chat.log("Calling for prepare context name...")
+                self.prepare_name(ctx)  # async
+                return True
+        return False
+
+    def store_history(self, ctx: CtxItem, type: str) -> bool:
+        """
+        Store ctx in history if enabled
+
+        :param ctx: CtxItem
+        :param type: input|output
+        :return: Tru if stored
+        """
+        # store to history
+        if self.window.core.config.get('store_history'):
+            self.window.core.history.append(ctx, type)
+            return True
+        return False
+
     def reload(self):
         """Reload ctx"""
         self.window.core.ctx.reset()

pygpt_net/controller/files/files.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.10 18:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 import datetime
@@ -497,6 +497,18 @@ class Files:
             path = path[1:]
         return path
 
+    def reset(self):
+        """Reset uploaded IDs"""
+        self.uploaded_ids = []
+
+    def get_ids(self) -> list:
+        """
+        Get uploaded files IDs
+
+        :return: uploaded files IDs
+        """
+        return self.uploaded_ids
+
     def reload(self):
         """Reload files"""
         self.update_explorer(reload=True)

pygpt_net/controller/idx/idx.py

@@ -6,12 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.16 20:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 import datetime
 from typing import Optional
 
+from pygpt_net.core.events import BaseEvent, Event
 from pygpt_net.item.ctx import CtxItem
 from pygpt_net.utils import trans
 
@@ -19,7 +20,6 @@ from .common import Common
 from .indexer import Indexer
 from .settings import Settings
 
-
 class Idx:
     def __init__(self, window=None):
         """
@@ -56,6 +56,22 @@ class Idx:
         self.update()
         self.locked = False
 
+    def handle(self, event: BaseEvent):
+        """
+        Handle events
+
+        :param event: BaseEvent: Event to handle
+        """
+        name = event.name
+
+        # on input begin, unlock experts and reset evaluation steps
+        if name == Event.CTX_END:
+            mode = event.data.get("mode", "")
+            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(event.ctx, mode=mode)  # update ctx DB index
+                # disabled in agent mode here to prevent loops, handled in agent flow internally if agent mode
+
     def get_modes_keys(self) -> list:
         """
         Get list of available modes
@@ -342,6 +358,14 @@ class Idx:
         """
         return self.current_idx is not None and self.current_idx != "_"
 
+    def get_current(self) -> str:
+        """
+        Get current index name
+
+        :return: Current index name
+        """
+        return self.current_idx
+
     def is_stopped(self) -> bool:
         """
         Check if indexing is stopped