pygpt-net 2.6.0.post2__py3-none-any.whl → 2.6.2__py3-none-any.whl

pygpt_net/core/agents/runner.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 13:00:00                  #
 # ================================================== #
 
 import asyncio
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Union
 
 from llama_index.core.base.llms.types import ChatMessage, MessageRole
 
@@ -24,6 +24,8 @@ from pygpt_net.core.types import (
     AGENT_MODE_OPENAI,
 )
 
+from pygpt_net.item.ctx import CtxItem
+
 from .runners.llama_assistant import LlamaAssistant
 from .runners.llama_plan import LlamaPlan
 from .runners.llama_steps import LlamaSteps
@@ -33,6 +35,11 @@ from .runners.helpers import Helpers
 from .runners.loop import Loop
 
 class Runner:
+
+    APPEND_SYSTEM_PROMPT_TO_MSG = [
+        "react",  # llama-index
+    ]
+
     def __init__(self, window=None):
         """
         Agent runner
@@ -80,8 +87,9 @@ class Runner:
 
             # prepare agent
             model = context.model
-            vector_store_idx = extra.get("agent_idx", None)            
+            vector_store_idx = extra.get("agent_idx", None)
             system_prompt = context.system_prompt
+            preset = context.preset
             max_steps = self.window.core.config.get("agent.llama.steps", 10)
             is_stream = self.window.core.config.get("stream", False)
             is_cmd = self.window.core.command.is_cmd(inline=False)
@@ -89,6 +97,10 @@ class Runner:
             llm = self.window.core.idx.llm.get(model, stream=False)
             workdir = self.window.core.config.get_workdir_prefix()
 
+            # vector store idx from preset
+            if preset:
+                vector_store_idx = preset.idx
+
             # tools
             self.window.core.agents.tools.context = context
             self.window.core.agents.tools.agent_idx = vector_store_idx
@@ -107,12 +119,7 @@ class Runner:
                 tools = []
             
             # append system prompt
-            if agent_id not in [
-                "openai_agent_base",  # openai-agents
-                "openai_agent_experts",  # openai-agents
-                "openai_assistant", # llama-index
-                "code_act", # llama-index
-            ]:
+            if agent_id in self.APPEND_SYSTEM_PROMPT_TO_MSG:
                 if system_prompt:
                     msg = ChatMessage(
                         role=MessageRole.SYSTEM,
@@ -174,10 +181,117 @@ class Runner:
                 return asyncio.run(self.openai_workflow.run(**kwargs))
 
         except Exception as e:
+            print("Error in agent runner:", e)
             self.window.core.debug.error(e)
             self.last_error = e
             return False
 
+    def call_once(
+            self,
+            context: BridgeContext,
+            extra: Dict[str, Any],
+            signals: BridgeSignals
+    ) -> Union[CtxItem, bool, None]:
+        """
+        Call an agent once (quick call to the agent)
+
+        :param context: BridgeContext
+        :param extra: extra data
+        :param signals: BridgeSignals
+        :return: CtxItem if success, True if stopped, None on error
+        """
+        if self.window.controller.kernel.stopped():
+            return True  # abort if stopped
+
+        agent_id = extra.get("agent_provider", "openai")
+        verbose = self.window.core.config.get("agent.llama.verbose", False)
+
+        try:
+            # prepare input ctx
+            ctx = context.ctx
+            ctx.extra["agent_input"] = True  # mark as user input
+            ctx.extra["agent_output"] = True  # mark as user input
+            ctx.agent_call = True  # disables reply from plugin commands
+            prompt = context.prompt
+
+            # prepare agent
+            model = context.model
+            vector_store_idx = extra.get("agent_idx", None)
+            system_prompt = context.system_prompt
+            max_steps = self.window.core.config.get("agent.llama.steps", 10)
+            is_cmd = self.window.core.command.is_cmd(inline=False)
+            llm = self.window.core.idx.llm.get(model, stream=False)
+            workdir = self.window.core.config.get_workdir_prefix()
+
+            # tools
+            self.window.core.agents.tools.context = context
+            self.window.core.agents.tools.agent_idx = vector_store_idx
+
+            if "agent_tools" in extra:
+                tools = extra["agent_tools"]  # use tools from extra if provided
+            else:
+                tools = self.window.core.agents.tools.prepare(context, extra, force=True)
+
+            if "agent_history" in extra:
+                history = extra["agent_history"]
+            else:
+                history = self.window.core.agents.memory.prepare(context)
+
+            # disable tools if cmd is not enabled
+            if not is_cmd:
+                tools = []
+
+            # append system prompt
+            if agent_id in self.APPEND_SYSTEM_PROMPT_TO_MSG:
+                if system_prompt:
+                    msg = ChatMessage(
+                        role=MessageRole.SYSTEM,
+                        content=system_prompt,
+                    )
+                    history.insert(0, msg)
+
+            agent_kwargs = {
+                "context": context,
+                "tools": tools,
+                "llm": llm,
+                "model": model,
+                "chat_history": history,
+                "max_iterations": max_steps,
+                "verbose": verbose,
+                "system_prompt": system_prompt,
+                "are_commands": is_cmd,
+                "workdir": workdir,
+                "preset": context.preset if context else None,
+            }
+
+            if self.window.core.agents.provider.has(agent_id):
+                provider = self.window.core.agents.provider.get(agent_id)
+                agent = provider.get_agent(self.window, agent_kwargs)
+                if verbose:
+                    print("Using Agent: " + str(agent_id) + ", model: " + str(model.id))
+            else:
+                raise Exception("Agent not found: " + str(agent_id))
+
+            # run agent and return result
+            mode = provider.get_mode()
+            kwargs = {
+                "agent": agent,
+                "ctx": ctx,
+                "prompt": prompt,
+                "signals": signals,
+                "verbose": verbose,
+                "history": history,
+                "llm": llm,
+            }
+            # TODO: add support for other modes
+            if mode == AGENT_MODE_WORKFLOW:
+                return asyncio.run(self.llama_workflow.run_once(**kwargs))
+
+        except Exception as e:
+            self.window.core.debug.error(e)
+            self.last_error = e
+            return None
+
     def get_error(self) -> Optional[Exception]:
         """
         Get last error

pygpt_net/core/agents/runners/helpers.py

@@ -6,12 +6,12 @@
 # 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.14 01:00:00                  #
 # ================================================== #
 
 import copy
 import re
-import weakref
+import time
 from typing import Optional, Tuple
 
 from pygpt_net.core.bridge.context import BridgeContext
@@ -82,6 +82,7 @@ class Helpers:
         # ctx.attachments = from_ctx.attachments # copy from parent if appended from plugins
         # ctx.files = from_ctx.files  # copy from parent if appended from plugins
         ctx.extra = from_ctx.extra.copy()  # copy extra data
+        ctx.output_timestamp = int(time.time())  # set output timestamp
         return ctx
 
     def send_stream(

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 13: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 (
@@ -578,7 +577,7 @@ class ExpertWorker(QRunnable):
         try:
             # get or create children (slave) meta
             slave = self.window.core.ctx.get_or_create_slave_meta(master_ctx, expert_id)
-            expert = self.window.core.experts.get_expert(expert_id)
+            expert = self.window.core.experts.get_expert(expert_id)  # preset
             reply = True
             hidden = False
             internal = False
@@ -605,7 +604,7 @@ class ExpertWorker(QRunnable):
             stream_mode = self.window.core.config.get('stream')
             verbose = self.window.core.config.get('agent.llama.verbose')
             use_agent = self.window.core.config.get('experts.use_agent', False)
-            db_idx = self.window.controller.idx.current_idx  # get idx from agent config
+            db_idx = expert.idx  # get idx from expert preset
 
             mode = MODE_EXPERT  # force expert mode, mode will change in bridge
 
@@ -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)