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

pygpt_net/CHANGELOG.txt

@@ -1,3 +1,12 @@
+2.6.21 (2025-08-24)
+
+- Ollama models are now available in OpenAI Agents mode.
+- Improved parsing of responses from Agents.
+- Fix: do not initialize index in Agents mode if not provided.
+- Fix: agent response evaluation steps limit.
+- Fix: do not execute code in agents if Tools are disabled.
+- Refactoring.
+
 2.6.20 (2025-08-22)
 
 - Added a new plugin: Server (FTP/SSH) - connect to remote servers using FTP, SFTP, and SSH. Execute remote commands, upload, download, and more (beta).

pygpt_net/__init__.py

@@ -6,15 +6,15 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.22 00:00:00                  #
+# Updated Date: 2025.08.24 00:00:00                  #
 # ================================================== #
 
 __author__ = "Marcin Szczygliński"
 __copyright__ = "Copyright 2025, Marcin Szczygliński"
 __credits__ = ["Marcin Szczygliński"]
 __license__ = "MIT"
-__version__ = "2.6.20"
-__build__ = "2025-08-22"
+__version__ = "2.6.21"
+__build__ = "2025-08-24"
 __maintainer__ = "Marcin Szczygliński"
 __github__ = "https://github.com/szczyglis-dev/py-gpt"
 __report__ = "https://github.com/szczyglis-dev/py-gpt/issues"

pygpt_net/controller/agent/agent.py

@@ -6,9 +6,18 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.03 14:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
+from pygpt_net.core.events import BaseEvent, Event
+from pygpt_net.core.types import (
+    MODE_AGENT,
+    MODE_AGENT_LLAMA,
+    MODE_AGENT_OPENAI,
+)
+from pygpt_net.item.ctx import CtxItem
+from pygpt_net.utils import trans
+
 from .common import Common
 from .experts import Experts
 from .legacy import Legacy
@@ -28,7 +37,7 @@ class Agent:
         self.legacy = Legacy(window)
 
     def setup(self):
-        """Setup agent controller"""
+        """Setup agents"""
         self.legacy.setup()
         self.llama.setup()
 
@@ -41,3 +50,122 @@ class Agent:
         """Force stop all agents"""
         self.legacy.on_stop()
         self.llama.on_stop()
+
+    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.INPUT_BEGIN:
+            mode = event.data.get("mode", "")
+            force = event.data.get("force", False)
+            self.experts.unlock()  # unlock experts
+            self.llama.reset_eval_step()  # reset evaluation steps
+
+            if not force:
+                # if agent mode: iterations check, show alert confirm if infinity loop
+                if self.common.is_infinity_loop(mode):
+                    event.data["stop"] = True  # stop flow
+                    self.common.display_infinity_loop_confirm()
+                    return
+
+                # check if agent is selected
+                if mode in (MODE_AGENT_OPENAI, MODE_AGENT_LLAMA):
+                    preset = self.window.controller.presets.get_current()
+                    if not preset or preset.name == "*":
+                        event.data["stop"] = True  # stop flow
+                        self.window.ui.dialogs.alert(
+                            trans("dialog.agent.not_selected"))
+                        return
+
+        # on user send, start agent flow
+        elif name == Event.USER_SEND:
+            mode = event.data.get("mode", "")
+            text = event.data.get("value", "")
+            if mode == MODE_AGENT:
+                self.legacy.on_user_send(text)  # begin Legacy (autonomous) agent flow
+            elif mode in (
+                    MODE_AGENT_LLAMA,
+                    MODE_AGENT_OPENAI,
+            ):
+                self.llama.on_user_send(text)  # begin LlamaIndex adn OpenAI agent flow
+
+        # on input before, process text before sending input
+        elif name == Event.INPUT_BEFORE:
+            mode = event.data.get("mode", "")
+            if mode == MODE_AGENT:
+                text = event.data.get("value", "")
+                self.window.controller.chat.log(f"Agent: input before: {text}")
+                event.data["value"] = self.legacy.on_input_before(text)
+
+        # on pre-prompt
+        elif name == Event.PRE_PROMPT:
+            mode = event.data.get("mode", "")
+            sys_prompt = event.data.get("value", "")
+            is_expert = event.data.get("is_expert", False)
+            if is_expert:
+                return # abort if expert call
+            event.data["value"] = self.experts.append_prompts(
+                mode,
+                sys_prompt,
+            )
+        # on ctx after
+        elif name == Event.CTX_BEFORE:
+            mode = event.data.get("mode", "")
+            if mode == MODE_AGENT:
+                self.legacy.on_ctx_before(event.ctx)
+
+        # on bridge before, prepare bridge context
+        elif name == Event.BRIDGE_BEFORE:
+            mode = event.data.get("mode", "")
+            bridge_context = event.data.get("context", None)
+            extra = event.data.get("extra", {})
+            if mode in (MODE_AGENT_LLAMA, MODE_AGENT_OPENAI):
+
+                # agent provider
+                agent_provider = None  # agent provider (llama or openai)
+                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")
+                agent_idx = self.window.core.config.get("agent.llama.idx")
+
+                extra["agent_idx"] = agent_idx
+                extra["agent_provider"] = agent_provider
+
+                # update assistant ID if assistant agent
+                if mode == MODE_AGENT_LLAMA:
+                    preset = self.window.controller.presets.get_current()
+                    if preset is not None:
+                        bridge_context.assistant_id = preset.assistant_id
+
+        # on ctx after
+        elif name == Event.CTX_AFTER:
+            mode = event.data.get("mode", "")
+            if mode == MODE_AGENT:
+                self.legacy.on_ctx_after(event.ctx)
+
+        # on ctx end
+        elif name == Event.CTX_END:
+            mode = event.data.get("mode", "")
+            if mode == MODE_AGENT:
+                iterations = int(self.window.core.config.get("agent.iterations"))
+                self.window.controller.chat.log(f"Agent: ctx end, iterations: {iterations}")
+                self.legacy.on_ctx_end(
+                    event.ctx,
+                    iterations=iterations,
+                )
+
+    def on_reply(self, ctx: CtxItem):
+        """
+        On reply event
+
+        :param ctx: CtxItem: Context item to handle reply for
+        """
+        if ctx.internal and self.legacy.enabled():
+            self.legacy.add_run()
+            self.legacy.update()

pygpt_net/controller/agent/experts.py

@@ -6,10 +6,10 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.25 22:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
-from typing import Optional, Any
+from typing import Any
 
 from pygpt_net.core.types import (
     MODE_AGENT,
@@ -31,79 +31,42 @@ class Experts:
         self.window = window
         self.is_stop = False
 
-    def stop(self):
-        """
-        Stop experts
-        """
-        self.is_stop = True
-
-    def stopped(self) -> bool:
-        """
-        Check if experts are stopped
-
-        :return: True if experts are stopped
-        """
-        return self.is_stop
-
-    def unlock(self):
-        """Unlock experts"""
-        self.is_stop = False
-
-    def enabled(self, check_inline = True) -> bool:
-        """
-        Check if experts are enabled
-
-         :param check_inline: check inline mode
-        :return: True if experts are enabled
-        """
-        modes = [MODE_EXPERT]
-        mode = self.window.core.config.get('mode')
-        if not check_inline:
-            if mode in modes:
-                return True
-            else:
-                return False
-        else:
-            if mode in modes or self.window.controller.plugins.is_type_enabled("expert"):
-                return True
-            else:
-                return False
-
     def append_prompts(
             self,
             mode: str,
             sys_prompt: str,
-            parent_id: Optional[str] = None
-    ):
+    ) -> str:
         """
         Append prompt to the window
 
         :param mode: Mode
         :param sys_prompt: Prompt text
-        :param parent_id: Parent ID
+        :return: Updated system prompt
         """
+        core = self.window.core
+        controller = self.window.controller
+
         # if agent enabled
-        if self.window.controller.agent.legacy.enabled():
+        if controller.agent.legacy.enabled():
             prev_prompt = sys_prompt
-            sys_prompt = self.window.core.prompt.get("agent.instruction")
+            sys_prompt = core.prompt.get("agent.instruction")
             if prev_prompt is not None and prev_prompt.strip() != "":
                 sys_prompt = sys_prompt + "\n\n" + prev_prompt  # append previous prompt
 
-        # expert or agent mode
-        if ((self.enabled() or self.window.controller.agent.legacy.enabled(check_inline=False))
-                and parent_id is None):  # master expert has special prompt
-            if self.window.controller.agent.legacy.enabled():  # if agent then leave agent prompt
-                sys_prompt += "\n\n" + self.window.core.experts.get_prompt()  # both, agent + experts
+        # if expert or agent mode
+        if self.enabled() or controller.agent.legacy.enabled(check_inline=False):  # master expert has special prompt
+            if controller.agent.legacy.enabled():  # if agent then leave agent prompt
+                sys_prompt += "\n\n" + core.experts.get_prompt()  # both, agent + experts
             else:
-                sys_prompt = self.window.core.experts.get_prompt()
+                sys_prompt = core.experts.get_prompt()
                 # mode = "chat"  # change mode to chat for expert
 
         # if global mode is agent
         if mode == MODE_AGENT:
-            sys_prompt = self.window.controller.agent.legacy.on_system_prompt(
+            sys_prompt = controller.agent.legacy.on_system_prompt(
                 sys_prompt,
                 append_prompt=None,  # sys prompt from preset is used here
-                auto_stop=self.window.core.config.get('agent.auto_stop'),
+                auto_stop=core.config.get('agent.auto_stop'),
             )
 
         return sys_prompt
@@ -113,60 +76,94 @@ class Experts:
         Handle mentions (calls) to experts
 
         :param ctx: CtxItem
+        :return: Number of calls made to experts
         """
-        stream_mode = self.window.core.config.get('stream')
+        core = self.window.core
+        controller = self.window.controller
+        dispatch = self.window.dispatch
+        log = self.log
+        stream = core.config.get('stream')
         num_calls = 0
 
         # extract expert mentions
-        if self.enabled() or self.window.controller.agent.legacy.enabled(check_inline=False):
+        if self.enabled() or controller.agent.legacy.enabled(check_inline=False):
             # re-send to master
             if ctx.sub_reply:
-                self.window.core.ctx.update_item(ctx)
-                self.window.core.experts.reply(ctx)
+                core.ctx.update_item(ctx)
+                core.experts.reply(ctx)
             else:
+                # abort if reply
+                if ctx.reply:
+                    return num_calls
+
                 # call experts
-                if not ctx.reply:
-                    mentions = self.window.core.experts.extract_calls(ctx)
-                    if mentions:
-                        num_calls = 0
-                        self.log("Calling experts...")
-                        data = {
-                            "meta": ctx.meta,
-                            "ctx": ctx,
-                            "stream": stream_mode,
-                        }
-                        event = RenderEvent(RenderEvent.END, data)
-                        self.window.dispatch(event)  # close previous render
-                        for expert_id in mentions:
-                            if not self.window.core.experts.exists(expert_id):
-                                self.log("Expert not found: " + expert_id)
-                                continue
-                            self.log("Calling: " + expert_id)
-                            ctx.sub_calls += 1
-
-                            # add to reply stack
-                            reply = ReplyContext()
-                            reply.type = ReplyContext.EXPERT_CALL
-                            reply.ctx = ctx
-                            reply.parent_id = expert_id
-                            reply.input = mentions[expert_id]
-
-                            # send to kernel
-                            context = BridgeContext()
-                            context.ctx = ctx
-                            context.reply_context = reply
-                            event = KernelEvent(KernelEvent.AGENT_CALL, {
-                                'context': context,
-                                'extra': {},
-                            })
-                            self.window.dispatch(event)
-
-                            num_calls += 1
-                        if num_calls > 0:
-                            return num_calls  # abort continue if expert call detected
+                mentions = core.experts.extract_calls(ctx)
+
+                if mentions:
+                    log("Calling experts...")
+                    dispatch(RenderEvent(RenderEvent.END, {
+                        "meta": ctx.meta,
+                        "ctx": ctx,
+                        "stream": stream,
+                    }))  # close previous render
+
+                    for expert_id in mentions:
+                        if not core.experts.exists(expert_id):
+                            log(f"Expert not found: {expert_id}")
+                            continue
+
+                        log(f"Calling: {expert_id}")
+                        ctx.sub_calls += 1
+
+                        # add to reply stack
+                        reply = ReplyContext()
+                        reply.type = ReplyContext.EXPERT_CALL
+                        reply.ctx = ctx
+                        reply.parent_id = expert_id
+                        reply.input = mentions[expert_id]
+
+                        # send to kernel
+                        context = BridgeContext()
+                        context.ctx = ctx
+                        context.reply_context = reply
+                        dispatch(KernelEvent(KernelEvent.AGENT_CALL, {
+                            'context': context,
+                            'extra': {},
+                        }))
+                        num_calls += 1
 
         return num_calls
 
+    def enabled(self, check_inline: bool = True) -> bool:
+        """
+        Check if experts are enabled
+
+        :param check_inline: check inline mode
+        :return: True if experts are enabled
+        """
+        modes = [MODE_EXPERT]
+        mode = self.window.core.config.get('mode')
+        if not check_inline:
+            return mode in modes
+        else:
+            return mode in modes or self.window.controller.plugins.is_type_enabled("expert")
+
+    def stopped(self) -> bool:
+        """
+        Check if experts are stopped
+
+        :return: True if experts are stopped
+        """
+        return self.is_stop
+
+    def stop(self):
+        """Stop experts"""
+        self.is_stop = True
+
+    def unlock(self):
+        """Unlock experts"""
+        self.is_stop = False
+
     def log(self, data: Any):
         """
         Log data to debug

pygpt_net/controller/agent/llama.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.01 03:00:00                  #
+# Updated Date: 2025.08.24 02:00:00                  #
 # ================================================== #
 
 from typing import Any
@@ -136,6 +136,7 @@ class Llama:
         # check max steps
         max_steps = int(self.window.core.config.get("agent.llama.max_eval"))
         if max_steps != 0 and self.get_eval_step() >= max_steps:
+            self.window.update_status(f"Stopped. Limit of max steps: {max_steps}")  # show info
             self.on_end()
             return  # abort if max steps reached
 

pygpt_net/controller/assistant/assistant.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.03 14:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 from typing import Optional
@@ -56,6 +56,23 @@ class Assistant:
         self.files.update_list()
         self.select_current()
 
+    def check(self) -> bool:
+        """
+        Check if assistants are loaded
+
+        :return: True if assistants are loaded
+        """
+        # check if assistant is selected
+        if self.window.core.config.get('assistant') is None \
+                or self.window.core.config.get('assistant') == "":
+            self.window.ui.dialogs.alert(trans('error.assistant_not_selected'))
+            return False
+        return True
+
+    def resume(self):
+        """Reset assistants state"""
+        self.threads.stop = False
+
     def update_list(self):
         """Update assistants list"""
         items = self.window.core.assistants.get_all()

pygpt_net/controller/attachment/attachment.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.16 01:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 import os
@@ -79,6 +79,22 @@ class Attachment:
         # update tokens counter (vision plugin, etc.)
         self.window.controller.ui.update_tokens()
 
+    def cleanup(self, ctx: CtxItem) -> bool:
+        """
+        Clear attachments list on ctx end
+
+        :param ctx: CtxItem
+        :return: True if cleared
+        """
+        auto_clear = self.window.core.config.get('attachments_send_clear')
+        if self.clear_allowed(ctx):
+            if auto_clear and not self.is_locked():
+                self.clear(force=True, auto=True)
+                self.update()
+                self.window.controller.chat.log("Attachments cleared.")  # log
+                return True
+        return False
+
     def update_tab(self, mode: str):
         """
         Update tab label

pygpt_net/controller/camera/camera.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.06 01:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 import datetime
@@ -19,6 +19,7 @@ from PySide6.QtGui import QImage, QPixmap, Qt
 
 from pygpt_net.core.events import AppEvent, KernelEvent
 from pygpt_net.core.camera import CaptureWorker
+from pygpt_net.core.types import MODE_ASSISTANT
 from pygpt_net.utils import trans
 
 
@@ -145,12 +146,19 @@ class Camera(QObject):
 
         return result
 
-    def handle_auto_capture(self):
-        """Handle auto capture"""
-        if self.is_enabled():
-            if self.is_auto():
-                self.capture_frame(switch=False)
-                self.window.controller.chat.log("Captured frame from camera.")  # log
+    def handle_auto_capture(self, mode: str):
+        """
+        Handle auto capture
+
+        :param mode: current mode
+        """
+        if mode == MODE_ASSISTANT:
+            return  # abort in Assistants mode
+        if self.window.controller.ui.vision.has_vision():
+            if self.is_enabled():
+                if self.is_auto():
+                    self.capture_frame(switch=False)
+                    self.window.controller.chat.log("Captured frame from camera.")  # log
 
     def get_current_frame(self, flip_colors: bool = True):
         """

pygpt_net/controller/chat/chat.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.15 23:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 from typing import Any
@@ -94,7 +94,7 @@ class Chat:
         """
         upper_mode = mode.upper()
         if self.window.core.config.get("log.ctx"):
-            self.log(f"[ctx] {upper_mode}: {ctx.dump()}")  # log
+            self.log(f"[ctx] {upper_mode}: {ctx.dump()}")
         else:
             self.log(f"[ctx] {upper_mode}.")