pygpt-net 2.6.8__py3-none-any.whl → 2.6.10__py3-none-any.whl

pygpt_net/provider/agents/openai/supervisor.py

@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.17 02:00:00                  #
+# ================================================== #
+
+import json
+import re
+from typing import Dict, Any, Tuple, Optional
+
+from agents import (
+    Agent as OpenAIAgent,
+    Runner,
+    RunConfig,
+    RunContextWrapper,
+    SQLiteSession,
+    ModelSettings,
+    function_tool,
+)
+
+from pygpt_net.core.agents.bridge import ConnectionContext
+from pygpt_net.core.bridge import BridgeContext
+from pygpt_net.core.types import (
+    AGENT_MODE_OPENAI,
+    AGENT_TYPE_OPENAI,
+)
+
+from pygpt_net.item.ctx import CtxItem
+from pygpt_net.item.model import ModelItem
+
+from pygpt_net.provider.gpt.agents.client import get_custom_model_provider, set_openai_env
+from pygpt_net.provider.gpt.agents.remote_tools import append_tools
+from pygpt_net.provider.gpt.agents.response import StreamHandler
+from pygpt_net.provider.gpt.agents.experts import get_experts
+
+from ..base import BaseAgent
+
+JSON_RE = re.compile(r"\{[\s\S]*\}$", re.MULTILINE)
+
+SUPERVISOR_PROMPT = """
+    You are the “Supervisor” (orchestrator). You never use tools directly except the tool that runs the Worker.
+    Process:
+    - Decompose the user's task into actionable instructions for the Worker.
+    - Do NOT pass your conversation history to the Worker. Pass ONLY a concise, self-contained instruction.
+    - After each Worker result, evaluate against a clear Definition of Done (DoD). If not met, call the Worker again with a refined instruction.
+    - Ask the user only if absolutely necessary. If you must, STOP and output a single JSON with:
+    {"action":"ask_user","question":"...","reasoning":"..."}
+    - When done, output a single JSON:
+    {"action":"final","final_answer":"...","reasoning":"..."}
+    - Otherwise, to run the Worker, call the run_worker tool with a short instruction.
+    Respond in the user's language. Keep outputs short and precise.
+    """
+
+WORKER_PROMPT = """
+You are the “Worker”. You execute Supervisor instructions strictly, using your tools.
+- Keep your own memory across calls (Worker session).
+- Return a concise result with key evidence/extracts from tools when applicable.
+- Do not ask the user questions directly; if instruction is underspecified, clearly state what is missing.
+Respond in the user's language.
+"""
+
+class Agent(BaseAgent):
+
+    def __init__(self, *args, **kwargs):
+        super(Agent, self).__init__(*args, **kwargs)
+        self.id = "openai_agent_supervisor"
+        self.type = AGENT_TYPE_OPENAI
+        self.mode = AGENT_MODE_OPENAI
+        self.name = "Supervisor + worker"
+
+    def get_agent(self, window, kwargs: Dict[str, Any]):
+        """
+        Return Agent supervisor instance
+
+        :param window: window instance
+        :param kwargs: keyword arguments
+        :return: Agent instance
+        """
+        context = kwargs.get("context", BridgeContext())
+        preset = context.preset
+        agent_name = preset.name if preset else "Supervisor"
+        model = kwargs.get("model", ModelItem())
+        worker_tool = kwargs.get("worker_tool", None)
+        kwargs = {
+            "name": agent_name,
+            "instructions": self.get_option(preset, "supervisor", "prompt"),
+            "model": model.id,
+        }
+        if worker_tool:
+            kwargs["tools"] = [worker_tool]
+        return OpenAIAgent(**kwargs)
+
+    def get_worker(self, window, kwargs: Dict[str, Any]):
+        """
+        Return Agent worker instance
+
+        :param window: window instance
+        :param kwargs: keyword arguments
+        :return: Agent instance
+        """
+        context = kwargs.get("context", BridgeContext())
+        preset = context.preset
+        agent_name = "Worker"  # Default worker name
+        tools = kwargs.get("function_tools", [])
+        model = window.core.models.get(
+            self.get_option(preset, "worker", "model")
+        )
+        handoffs = kwargs.get("handoffs", [])
+        kwargs = {
+            "name": agent_name,
+            "instructions": self.get_option(preset, "worker", "prompt"),
+            "model": model.id,
+        }
+        if handoffs:
+            kwargs["handoffs"] = handoffs
+
+        tool_kwargs = append_tools(
+            tools=tools,
+            window=window,
+            model=model,
+            preset=preset,
+            allow_local_tools=self.get_option(preset, "worker", "allow_local_tools"),
+            allow_remote_tools= self.get_option(preset, "worker", "allow_remote_tools"),
+        )
+        kwargs.update(tool_kwargs) # update kwargs with tools
+        return OpenAIAgent(**kwargs)
+
+    async def run(
+            self,
+            window: Any = None,
+            agent_kwargs: Dict[str, Any] = None,
+            previous_response_id: str = None,
+            messages: list = None,
+            ctx: CtxItem = None,
+            stream: bool = False,
+            bridge: ConnectionContext = None,
+            use_partial_ctx: Optional[bool] = False,
+    ) -> Tuple[CtxItem, str, str]:
+        """
+        Run agent (async)
+
+        :param window: Window instance
+        :param agent_kwargs: Additional agent parameters
+        :param previous_response_id: ID of the previous response (if any)
+        :param messages: Conversation messages
+        :param ctx: Context item
+        :param stream: Whether to stream output
+        :param bridge: Connection context for agent operations
+        :param use_partial_ctx: Use partial ctx per cycle
+        :return: Current ctx, final output, last response ID
+        """
+        final_output = ""
+        response_id = None
+        model = agent_kwargs.get("model", ModelItem())
+        verbose = agent_kwargs.get("verbose", False)
+        tools = agent_kwargs.get("function_tools", [])
+        context = agent_kwargs.get("context", BridgeContext())
+        preset = context.preset if context else None
+
+        # add experts
+        experts = get_experts(
+            window=window,
+            preset=preset,
+            verbose=verbose,
+            tools=tools,
+        )
+        if experts:
+            agent_kwargs["handoffs"] = experts
+
+        worker = self.get_worker(window, agent_kwargs)
+        max_steps = agent_kwargs.get("max_iterations", 10)
+        kwargs = {
+            "input": messages,
+            "max_turns": int(max_steps),
+        }
+        if model.provider != "openai":
+            custom_provider = get_custom_model_provider(window, model)
+            kwargs["run_config"] = RunConfig(model_provider=custom_provider)
+        else:
+            set_openai_env(window)
+            if previous_response_id:
+                kwargs["previous_response_id"] = previous_response_id
+
+        # temp worker memory
+        worker_session_id = f"worker_session_{ctx.meta.id}" if ctx.meta else "worker_session_default"
+        worker_session = SQLiteSession(worker_session_id)
+
+        handler = StreamHandler(window, bridge)
+        item_ctx = ctx
+
+        # tool to run Worker
+        @function_tool(name_override="run_worker")
+        async def run_worker(ctx: RunContextWrapper[Any], instruction: str) -> str:
+            """
+            Run the Worker with an instruction from the Supervisor and return its output.
+
+            :param ctx: Run context wrapper
+            :param instruction: Instruction for the Worker
+            :return: Output from the Worker
+            """
+            item_ctx.stream = f"\n\n**Supervisor --> Worker:** {instruction}\n\n"
+            bridge.on_step(item_ctx, True)
+            handler.begin = False
+            result = await Runner.run(
+                worker,
+                input=instruction,
+                session=worker_session,
+                max_turns=max_steps,
+            )
+            item_ctx.stream = f"\n\n{result.final_output}\n\n"
+            bridge.on_step(item_ctx, False)
+            return str(result.final_output)
+
+        agent_kwargs["worker_tool"] = run_worker
+        agent = self.get_agent(window, agent_kwargs)
+
+        if not stream:
+            result = await Runner.run(
+                agent,
+                **kwargs
+            )
+            final_output, last_response_id = window.core.gpt.responses.unpack_agent_response(result, ctx)
+            response_id = result.last_response_id
+            if verbose:
+                print("Final response:", result)
+        else:
+            result = Runner.run_streamed(
+                agent,
+                **kwargs
+            )
+            async for event in result.stream_events():
+                if bridge.stopped():
+                    result.cancel()
+                    bridge.on_stop(ctx)
+                    break
+                final_output, response_id = handler.handle(event, ctx)
+
+        # extract final output from JSON
+        if final_output:
+            final_output = self.extract_final_response(final_output)
+            if verbose:
+                print("Final output after extraction:", final_output)
+
+        return ctx, final_output, response_id
+
+    def extract_final_response(self, output: str) -> str:
+        """
+        Extract final response from the output string.
+
+        :param output: Output string from the agent
+        :return: Final response string
+        """
+        if not output:
+            return ""
+
+        fence = re.search(r"```json\s*([\s\S]*?)\s*```", output, re.IGNORECASE)
+        if fence:
+            try:
+                # Try to parse the fenced JSON
+                json_text = fence.group(1).strip()
+                json_response = json.loads(json_text)
+                return self.response_from_json(json_response)
+            except Exception:
+                pass
+
+        tail = JSON_RE.findall(output)
+        for candidate in tail[::-1]:
+            try:
+                # Try to parse the JSON from the tail
+                json_response = json.loads(candidate)
+                return self.response_from_json(json_response)
+            except Exception:
+                continue
+
+        if output.startswith("{") and output.endswith("}"):
+            try:
+                # Try to parse the entire output as JSON
+                response = json.loads(output)
+                return self.response_from_json(response)
+            except Exception as e:
+                print(f"Error parsing JSON: {e}")
+                return output
+
+        return output.strip()
+
+    def response_from_json(self, response: dict) -> str:
+        """
+        Extract response from JSON format
+
+        :param response: JSON response from the agent
+        :return: str: Formatted response string
+        """
+        action = response.get("action", "")
+        if action == "ask_user":
+            question = response.get("question", "")
+            reasoning = response.get("reasoning", "")
+            return f"**Supervisor:** {reasoning}\n\n{question}"
+        elif action == "final":
+            final_answer = response.get("final_answer", "")
+            reasoning = response.get("reasoning", "")
+            return f"**Supervisor:** {reasoning}\n\n{final_answer}\n\n"
+        else:
+            return response.get("final_answer", "")
+
+    def get_options(self) -> Dict[str, Any]:
+        """
+        Return Agent options
+
+        :return: dict of options
+        """
+        return {
+            "supervisor": {
+                "label": "Supervisor",
+                "options": {
+                    "prompt": {
+                        "type": "textarea",
+                        "label": "Prompt",
+                        "description": "Prompt for supervisor",
+                        "default": SUPERVISOR_PROMPT,
+                    },
+                }
+            },
+            "worker": {
+                "label": "Worker",
+                "options": {
+                    "model": {
+                        "label": "Model",
+                        "type": "combo",
+                        "use": "models",
+                        "default": "gpt-4o",
+                    },
+                    "prompt": {
+                        "type": "textarea",
+                        "label": "Prompt",
+                        "description": "Prompt for worker",
+                        "default": WORKER_PROMPT,
+                    },
+                    "allow_local_tools": {
+                        "type": "bool",
+                        "label": "Allow local tools",
+                        "description": "Allow usage of local tools for this agent",
+                        "default": True,
+                    },
+                    "allow_remote_tools": {
+                        "type": "bool",
+                        "label": "Allow remote tools",
+                        "description": "Allow usage of remote tools for this agent",
+                        "default": True,
+                    },
+                }
+            },
+        }
+
+
+
+

pygpt_net/provider/core/config/patch.py

@@ -2261,6 +2261,17 @@ class Patch:
                 self.window.core.updater.patch_css('style.dark.css', True)  # tree
                 updated = True
 
+            # < 2.6.10
+            if old < parse_version("2.6.10"):
+                print("Migrating config from < 2.6.10...")
+                if "agent.idx.auto_retrieve" not in data:
+                    data["agent.idx.auto_retrieve"] = True
+                if 'google' in data['plugins'] \
+                        and 'oauth_scopes' in data['plugins']['google']:
+                    # add documents scope
+                    if "https://www.googleapis.com/auth/documents" not in data['plugins']['google']['oauth_scopes']:
+                        data['plugins']['google']['oauth_scopes'] += " https://www.googleapis.com/auth/documents"
+                updated = True
 
         # update file
         migrated = False

pygpt_net/provider/core/preset/patch.py

@@ -39,6 +39,7 @@ class Patch:
         is_evolve = False
         is_b2b = False
         is_workflow = False
+        is_supervisor = False
 
         for k in self.window.core.presets.items:
             data = self.window.core.presets.items[k]
@@ -241,6 +242,23 @@ class Patch:
                         updated = True
                         save = True
 
+                # < 2.6.9
+                if old < parse_version("2.6.9"):
+                    if 'agent_openai_supervisor' not in self.window.core.presets.items and not is_supervisor:
+                        print("Migrating preset file from < 2.6.9...")
+                        files = [
+                            'agent_openai_supervisor.json',
+                            'agent_supervisor.json',
+                        ]
+                        for file in files:
+                            dst = os.path.join(self.window.core.config.get_user_dir('presets'), file)
+                            src = os.path.join(self.window.core.config.get_app_path(), 'data', 'config',
+                                               'presets', file)
+                            shutil.copyfile(src, dst)
+                            print("Patched file: {}.".format(dst))
+                        updated = True
+                        is_supervisor = True  # prevent multiple copies
+
             # update file
             if updated:
                 if save:

pygpt_net/ui/main.py

@@ -261,7 +261,7 @@ class MainWindow(QMainWindow, QtStyleTools):
         self.state = state
         self.ui.tray.set_icon(state)
 
-    @Slot(object)
+    @Slot(object, bool)
     def dispatch(self, event: BaseEvent, all: bool = False):
         """
         Dispatch App event

pygpt_net/ui/widget/lists/context.py

@@ -197,7 +197,7 @@ class ContextList(BaseList):
                     icon = self._color_icon(status_info['color'])
                     status_action = set_label_menu.addAction(icon, name)
                     status_action.triggered.connect(
-                        functools.partial(self.window.controller.ctx.set_label, ctx_id, status_id)
+                        functools.partial(self.action_set_label, ctx_id, status_id)
                     )
 
                 idx_menu = QMenu(trans('action.idx'), self)
@@ -387,6 +387,15 @@ class ContextList(BaseList):
         self.restore_after_ctx_menu = False
         self.window.controller.ctx.common.reset(id)
 
+    def action_set_label(self, id: int, label: int):
+        """
+        Set label action handler
+
+        :param id: context id
+        :param label: label id
+        """
+        self.window.controller.ctx.set_label(id, label)
+
     def selectionCommand(self, index, event=None):
         """
         Selection command

pygpt_net/ui/widget/textarea/web.py

@@ -54,9 +54,7 @@ class ChatWebOutput(QWebEngineView):
         self.setPage(CustomWebEnginePage(self.window, self, profile=self._profile))
 
     def _detach_gl_event_filter(self):
-        """
-        Detach OpenGL widget event filter if installed
-        """
+        """Detach OpenGL widget event filter if installed"""
         if self._glwidget and self._glwidget_filter_installed:
             try:
                 self._glwidget.removeEventFilter(self)
@@ -95,8 +93,9 @@ class ChatWebOutput(QWebEngineView):
             return
         try:
             # detach the channel from the page to break JS<->Python references
+            page.cleanup()
             page.setWebChannel(None)
-        except Exception:
+        except Exception as e:
             pass
 
         # bridge, channel, and signals have parent=page, so deleteLater of the page will clean them up
@@ -500,6 +499,39 @@ class CustomWebEnginePage(QWebEnginePage):
     def javaScriptConsoleMessage(self, level, message, line_number, source_id):
         self.signals.js_message.emit(line_number, message, source_id)  # handled in debug controller
 
+    def cleanup(self):
+        """Cleanup method to release resources"""
+        try:
+            self.findTextFinished.disconnect()
+            self.zoomFactorChanged.disconnect()
+            self.selectionChanged.disconnect()
+        except Exception:
+            pass
+
+        if self.bridge:
+            try:
+                self.bridge.cleanup()
+            except Exception:
+                pass
+            self.bridge = None
+
+        if self.channel:
+            try:
+                self.channel.unregisterObject("bridge")
+            except Exception:
+                pass
+            self.channel = None
+
+        if self.signals:
+            try:
+                self.signals.deleteLater()
+            except Exception:
+                pass
+            self.signals = None
+
+        # delete the page object
+        self.deleteLater()
+
 
 class Bridge(QObject):
     """Bridge between Python and JavaScript"""
@@ -534,6 +566,17 @@ class Bridge(QObject):
     def update_scroll_position(self, pos: int):
         self.window.controller.chat.render.scroll = pos
 
+    def cleanup(self):
+        """Cleanup method to release resources"""
+        if self.window:
+            try:
+                self.window = None
+            except Exception:
+                pass
+
+        # delete the bridge object
+        self.deleteLater()
+
 
 class WebEngineSignals(QObject):
     save_as = Signal(str, str)