pygpt-net 2.6.0.post1__py3-none-any.whl → 2.6.1__py3-none-any.whl

pygpt_net/core/agents/runners/llama_workflow.py

@@ -6,11 +6,11 @@
 # 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.14 01:00:00                  #
 # ================================================== #
 
 import re
-from typing import Optional, Any, List
+from typing import Optional, Any, List, Union
 
 from llama_index.core.workflow import Context
 from llama_index.core.agent.workflow import (
@@ -19,9 +19,12 @@ from llama_index.core.agent.workflow import (
     AgentStream,
     AgentOutput,
 )
+from workflows.errors import WorkflowCancelledByUser
+
 from pygpt_net.core.bridge.worker import BridgeSignals
 from pygpt_net.core.events import KernelEvent
 from pygpt_net.item.ctx import CtxItem
+from pygpt_net.provider.agents.llama_index.workflow.events import StepEvent
 
 from .base import BaseRunner
 
@@ -64,22 +67,103 @@ class LlamaWorkflow(BaseRunner):
         agent_ctx = Context(agent)
         memory = self.window.core.idx.chat.get_memory_buffer(history, llm)
         self.set_busy(signals)
-        await self.run_agent(
-            agent=agent,
-            ctx=agent_ctx,
-            query=prompt,
-            memory=memory,
-            verbose=verbose,
-            item_ctx=ctx,
-            signals=signals,
-        )
+
+        try:
+            ctx = await self.run_agent(
+                agent=agent,
+                ctx=agent_ctx,
+                query=prompt,
+                memory=memory,
+                verbose=verbose,
+                item_ctx=ctx,
+                signals=signals,
+                use_partials=self.window.core.config.get("agent.openai.response.split", True)
+            )
+        except WorkflowCancelledByUser:
+            print("\n\n[STOP] Workflow stopped by user.")
+        except Exception as e:
+            self.window.core.debug.log(f"Error running agent workflow: {e}")
+            ctx.extra["error"] = str(e)
+            self.set_idle(signals)
+            return False
+
+        if ctx.partial:
+            ctx.partial = False  # reset partial flag
+
+        response_ctx = self.make_response(ctx)
+        self.end_stream(response_ctx, signals)
+        self.send_response(response_ctx, signals, KernelEvent.APPEND_DATA)  # send response
+
+        self.set_idle(signals)
+        return True
+
+    async def run_once(
+            self,
+            agent: Any,
+            ctx: CtxItem,
+            prompt: str,
+            signals: BridgeSignals,
+            verbose: bool = False,
+            history: List[CtxItem] = None,
+            llm: Any = None,
+    ) -> Union[CtxItem, None]:
+        """
+        Run agent workflow
+
+        :param agent: Agent instance
+        :param ctx: Input context
+        :param prompt: input text
+        :param signals: BridgeSignals
+        :param verbose: verbose mode
+        :param history: chat history
+        :param llm: LLM instance
+        :return: True if success
+        """
+        if self.is_stopped():
+            return None  # abort if stopped
+
+        memory = self.window.core.idx.chat.get_memory_buffer(history, llm)
+        agent_ctx = Context(agent)
+        try:
+            ctx = await self.run_agent(
+                agent=agent,
+                ctx=agent_ctx,
+                query=prompt,
+                memory=memory,
+                verbose=verbose,
+                item_ctx=ctx,
+                signals=signals,
+                use_partials=False,  # use partials for streaming
+            )
+        except WorkflowCancelledByUser:
+            print("\n\n[STOP] Workflow stopped by user.")
+        except Exception as e:
+            self.window.core.debug.log(f"Error running agent workflow: {e}")
+            ctx.extra["error"] = str(e)
+            return None
+
+        if ctx.agent_final_response:
+            ctx.output = ctx.agent_final_response  # set output to current context
+        else:
+            ctx.output = ctx.live_output
+
+        return ctx
+
+    def make_response(
+            self,
+            ctx: CtxItem
+    ) -> CtxItem:
+        """
+        Create a response context item with the given input and output.
+
+        :param ctx: CtxItem - the context item to use as a base
+        """
         response_ctx = self.add_ctx(ctx, with_tool_outputs=True)
-        response_ctx.set_input("inp")
+        response_ctx.set_input("")
 
         prev_output = ctx.live_output
-        # remove all <execute>...</execute>
         if prev_output:
-            prev_output = re.sub(r'<execute>.*?</execute>', '', prev_output, flags=re.DOTALL)
+            prev_output = self.filter_output(prev_output)  # remove all <execute>...</execute>
 
         response_ctx.set_agent_final_response(ctx.agent_final_response)  # always set to further use
         response_ctx.set_output(prev_output)  # append from stream
@@ -94,12 +178,19 @@ class LlamaWorkflow(BaseRunner):
             self.window.core.agents.tools.append_tool_outputs(response_ctx)
         else:
             self.window.core.agents.tools.extract_tool_outputs(response_ctx)
-        self.end_stream(response_ctx, signals)
 
-        # send response
-        self.send_response(response_ctx, signals, KernelEvent.APPEND_DATA)
-        self.set_idle(signals)
-        return True
+        return response_ctx
+
+    def filter_output(self, output: str) -> str:
+        """
+        Filter output to remove unwanted tags
+
+        :param output: Output string
+        :return: Filtered output string
+        """
+        # Remove <execute>...</execute> tags
+        filtered_output = re.sub(r'<execute>.*?</execute>', '', output, flags=re.DOTALL)
+        return filtered_output
 
     async def run_agent(
             self,
@@ -109,7 +200,9 @@ class LlamaWorkflow(BaseRunner):
             memory,
             verbose=False,
             item_ctx: Optional[CtxItem] = None,
-            signals: Optional[BridgeSignals] = None):
+            signals: Optional[BridgeSignals] = None,
+            use_partials: bool = True,
+    ):
         """
         Run agent workflow
         This method runs the agent's workflow, processes tool calls, and streams events.
@@ -121,9 +214,16 @@ class LlamaWorkflow(BaseRunner):
         :param verbose: Verbose mode (default: False)
         :param item_ctx: Optional CtxItem for additional context
         :param signals: Optional BridgeSignals for communication
+        :param use_partials: If True, use partial context items for streaming
         :return: handler for the agent workflow
         """
-        handler = agent.run(query, ctx=ctx, memory=memory, verbose=verbose)
+        handler = agent.run(
+            query,
+            ctx=ctx,
+            memory=memory,
+            verbose=verbose,
+            on_stop=self.is_stopped,
+        )
         if verbose:
             print(f"User:  {query}")
 
@@ -134,7 +234,11 @@ class LlamaWorkflow(BaseRunner):
 
         async for event in handler.stream_events():
             if self.is_stopped():
+                # persist current output on stop
+                item_ctx.output = item_ctx.live_output
+                self.window.core.ctx.update_item(item_ctx)
                 self.end_stream(item_ctx, signals)
+                await handler.cancel_run()  # cancel, will raise WorkflowCancelledByUser
                 break
             if isinstance(event, ToolCallResult):
                 output = f"\n-----------\nExecution result:\n{event.tool_output}"
@@ -155,6 +259,19 @@ class LlamaWorkflow(BaseRunner):
                     item_ctx.stream = formatted
                     if item_ctx.stream_agent_output:
                         self.send_stream(item_ctx, signals, begin)
+            elif isinstance(event, StepEvent):
+                self.set_busy(signals)
+                if not use_partials:
+                    continue
+                if verbose:
+                    print("\n\n-----STEP-----\n\n")
+                    print(f"[{event.name}] {event.index}/{event.total} meta={event.meta}")
+                item_ctx = self.on_next_ctx(
+                    item_ctx,
+                    signals=signals,
+                    begin=begin,
+                    stream=True,
+                )
             elif isinstance(event, AgentStream):
                 if verbose:
                     print(f"{event.delta}", end="", flush=True)
@@ -171,4 +288,41 @@ class LlamaWorkflow(BaseRunner):
                     if verbose:
                         print(f"\nFinal response: {answer}")
 
-        return await handler
+        return item_ctx
+
+    def on_next_ctx(
+            self,
+            ctx: CtxItem,
+            signals: BridgeSignals,
+            begin: bool = False,
+            stream: bool = True,
+    ) -> CtxItem:
+        """
+        Callback for next context in cycle
+
+        :param ctx: CtxItem
+        :param signals: BridgeSignals
+        :param begin: if True, flush current output to before buffer and clear current buffer
+        :param stream: is streaming enabled
+        :return: CtxItem - the next context item in the cycle
+        """
+        # finish current stream
+        ctx.stream = "\n"
+        ctx.extra["agent_output"] = True  # allow usage in history
+        ctx.output = ctx.live_output  # set output to current context
+        ctx.output = self.filter_output(ctx.output)
+        self.window.core.ctx.update_item(ctx)
+
+        if stream:
+            self.send_stream(ctx, signals, begin)
+            self.end_stream(ctx, signals)
+
+        # create and return next context item
+        next_ctx = self.add_next_ctx(ctx)
+        next_ctx.set_input("")
+        next_ctx.set_output("")
+        next_ctx.partial = True
+        next_ctx.extra["agent_output"] = True  # allow usage in history
+
+        self.send_response(next_ctx, signals, KernelEvent.APPEND_DATA)
+        return next_ctx

pygpt_net/core/agents/runners/loop.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.14 03:00:00                  #
 # ================================================== #
 
 from typing import Optional, List
@@ -51,20 +51,28 @@ class Loop(BaseRunner):
         if self.is_stopped():
             return ""  # abort if stopped
 
-        verbose = self.window.core.config.get("agent.llama.verbose", False)
         model = self.window.core.models.get(model_name)
-        llm = self.window.core.idx.llm.get(model, stream=False)
-        kwargs = {
-            "context": BridgeContext(),
-            "tools": tools,
-            "llm": llm,
-            "chat_history": [],
-            "max_iterations": 10,
-            "verbose": verbose,
+        ctx = CtxItem()
+        bridge_context = BridgeContext(
+            ctx=ctx,
+            history=[],
+            model=model,
+            prompt=self.prepare_input(input),
+            stream=False,
+        )
+        extra = {
+            "agent_provider": "react",  # use React workflow provider
+            "agent_tools": tools,
         }
-        provider = self.window.core.agents.provider.get("react")
-        agent = provider.get_agent(self.window, kwargs)
-        return agent.chat(self.prepare_input(input))
+        response_ctx = self.window.core.agents.runner.call_once(
+            context=bridge_context,
+            extra=extra,
+            signals=None,
+        )
+        if response_ctx:
+            return str(response_ctx.output)
+        else:
+            return "No response from evaluator."
 
     def run_next(
             self,
@@ -166,6 +174,7 @@ class Loop(BaseRunner):
         context.history = self.window.core.ctx.all(meta_id=ctx.meta.id)
         context.prompt = instruction  # use instruction as prompt
         preset = self.window.controller.presets.get_current()
+        context.preset = preset
         extra = {
             "agent_idx": preset.idx,
             "agent_provider": preset.agent_provider,

pygpt_net/core/experts/experts.py

@@ -6,14 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.11 14:00:00                  #
+# Updated Date: 2025.08.14 01:00:00                  #
 # ================================================== #
 
 import json
 from typing import Dict, List, Optional
 
 from PySide6.QtCore import QRunnable, QObject, Signal, Slot
-from llama_index.core.base.llms.types import ChatMessage, MessageRole
 from llama_index.core.tools import QueryEngineTool
 
 from pygpt_net.core.types import (
@@ -858,29 +857,24 @@ class ExpertWorker(QRunnable):
         :return: True if success, False otherwise
         """
         history = self.window.core.agents.memory.prepare(context)
-        if system_prompt:
-            msg = ChatMessage(
-                role=MessageRole.SYSTEM,
-                content=system_prompt
-            )
-            history.insert(0, msg)
-        kwargs = {
-            "context": context,
-            "tools": tools,
-            "llm": llm,
-            "chat_history": history,
-            "max_iterations": 30,
-            "verbose": verbose,
-            "system_prompt": system_prompt,
-            "are_commands": self.window.core.config.get("cmd"),
-        }
-        provider = self.window.core.agents.provider.get("planner")
-        agent = provider.get_agent(self.window, kwargs)
-        response_ctx = self.window.core.agents.runner.llama_plan.run_once(
-            agent=agent,
+        bridge_context = BridgeContext(
             ctx=ctx,
+            system_prompt=system_prompt,
+            model=context.model,
             prompt=query,
-            verbose=verbose,
+            stream=False,
+            is_expert_call=True,  # mark as expert call
+        )
+        extra = {
+            "agent_provider": "react",  # use react workflow provider
+            "agent_idx": context.idx,  # index to use
+            "agent_tools": tools,  # tools to use
+            "agent_history": history,  # already prepared history
+        }
+        response_ctx = self.window.core.agents.runner.call_once(
+            context=bridge_context,
+            extra=extra,
+            signals=None,
         )
         if response_ctx:
             return str(response_ctx.output)

pygpt_net/core/idx/chat.py

@@ -6,9 +6,9 @@
 # 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.14 01:00:00                  #
 # ================================================== #
-import asyncio
+
 import json
 from typing import Optional, Dict, Any, List
 
@@ -338,7 +338,7 @@ class Chat:
                         tools=tools,
                         ctx=ctx,
                         query=query,
-                        history=history,
+                        history=context.history,
                         llm=llm,
                         index=index,
                         system_prompt=system_prompt,
@@ -377,7 +377,7 @@ class Chat:
                         tools=tools,
                         ctx=ctx,
                         query=query,
-                        history=history,
+                        history=context.history,
                         llm=llm,
                         index=index,
                         system_prompt=system_prompt,
@@ -490,7 +490,7 @@ class Chat:
             chat_mode: str = MODE_CHAT,
             verbose: bool = False,
 
-    ) -> bool:
+    ) -> str:
         """
         Call agent with tools and index
 
@@ -507,7 +507,6 @@ class Chat:
         :param verbose: Verbose mode, default is False
         :return: True if success, False otherwise
         """
-        index_tool = None
         if index:
             query_engine = index.as_query_engine(
                 llm=llm,
@@ -522,35 +521,26 @@ class Chat:
             )
             tools.append(index_tool)
 
-        workdir = self.window.core.config.get_user_dir('data')
-        if self.window.core.plugins.get_option("cmd_code_interpreter", "sandbox_ipython"):
-            workdir = "/data"
-
-        kwargs = {
-            "context": context,
-            "tools": tools,
-            "retriever_tool": index_tool,
-            "llm": llm,
-            "chat_history": history,
-            "max_iterations": 0,
-            "verbose": verbose,
-            "system_prompt": system_prompt,
-            "are_commands": True,
-            "workdir": workdir,
-        }
-        provider = self.window.core.agents.provider.get("react_workflow")
-        agent = provider.get_agent(self.window, kwargs)
-
-        kwargs = {
-            "agent": agent,
-            "ctx": ctx,
-            "prompt": query,
-            "signals": signals,
-            "verbose": verbose,
-            "history": history,
-            "llm": llm,
+        bridge_context = BridgeContext(
+            ctx=ctx,
+            model=context.model,
+            history=history,
+            prompt=query,
+            stream=False,
+        )
+        extra = {
+            "agent_provider": "react",  # use React workflow provider
+            "agent_tools": tools,
         }
-        return asyncio.run(self.window.core.agents.runner.llama_workflow.run(**kwargs))
+        response_ctx = self.window.core.agents.runner.call_once(
+            context=bridge_context,
+            extra=extra,
+            signals=None,
+        )
+        if response_ctx:
+            return str(response_ctx.output)
+        else:
+            return "No response from agent."
 
     def is_stream_allowed(self) -> bool:
         """

pygpt_net/core/idx/response.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.22 22:00:00                  #
+# Updated Date: 2025.08.14 01:00:00                  #
 # ================================================== #
 
 from typing import Any
@@ -28,7 +28,10 @@ class Response:
             model: ModelItem,
             response: Any
     ) -> None:
-        pass
+        output = str(response)
+        if output is None:
+            output = ""
+        ctx.set_output(output, "")
 
     def from_index(
             self,