pygpt-net 2.6.58__py3-none-any.whl → 2.6.60__py3-none-any.whl

pygpt_net/core/agents/custom/utils.py

@@ -0,0 +1,181 @@
+#!/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.09.24 23:00:00                  #
+# ================================================== #
+
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
+
+from agents import TResponseInputItem
+from pygpt_net.item.model import ModelItem
+from pygpt_net.item.preset import PresetItem
+
+
+# ---------- IO sanitization / output helpers ----------
+
+def sanitize_input_items(items: List[TResponseInputItem]) -> List[TResponseInputItem]:
+    """Remove server-assigned ids from items and content parts to avoid duplication errors."""
+    sanitized: List[TResponseInputItem] = []
+    for it in items or []:
+        if isinstance(it, dict):
+            new_it: Dict[str, Any] = dict(it)
+            # top-level ids that might reappear
+            new_it.pop("id", None)
+            new_it.pop("message_id", None)
+            # sanitize content list parts
+            if "content" in new_it and isinstance(new_it["content"], list):
+                new_content = []
+                for part in new_it["content"]:
+                    if isinstance(part, dict):
+                        p = dict(part)
+                        p.pop("id", None)
+                        new_content.append(p)
+                    else:
+                        new_content.append(part)
+                new_it["content"] = new_content
+            sanitized.append(new_it)
+        else:
+            sanitized.append(it)
+    return sanitized
+
+
+def extract_text_output(result: Any) -> str:
+    """
+    Best-effort to get a human-facing text from openai-agents Runner result
+    without relying on app-specific helpers.
+    """
+    out = getattr(result, "final_output", None)
+    if out is None:
+        return ""
+    try:
+        return str(out)
+    except Exception:
+        return ""
+
+
+def patch_last_assistant_output(items: List[TResponseInputItem], text: str) -> List[TResponseInputItem]:
+    """
+    Replace the content of the last assistant message with plain text content.
+    This prevents leaking router JSON to subsequent agents.
+    """
+    if not items:
+        return items
+    patched = list(items)
+    # find last assistant
+    idx: Optional[int] = None
+    for i in range(len(patched) - 1, -1, -1):
+        it = patched[i]
+        if isinstance(it, dict) and it.get("role") == "assistant":
+            idx = i
+            break
+    if idx is None:
+        return patched
+
+    # set standard output_text content
+    patched[idx] = {
+        "role": "assistant",
+        "content": [
+            {
+                "type": "output_text",
+                "text": text or "",
+            }
+        ],
+    }
+    return sanitize_input_items(patched)
+
+
+# ---------- Per-agent options resolution ----------
+
+OptionGetter = Callable[[str, str, Any], Any]
+
+
+def make_option_getter(base_agent, preset: Optional[PresetItem]) -> OptionGetter:
+    """
+    Returns option_get(section, key, default) bound to your BaseAgent.get_option semantics.
+    section == node.id (e.g. "agent_1"), key in {"model","prompt","allow_local_tools","allow_remote_tools"}.
+    """
+    def option_get(section: str, key: str, default: Any = None) -> Any:
+        if preset is None:
+            return default
+        try:
+            val = base_agent.get_option(preset, section, key)
+            return default if val in (None, "") else val
+        except Exception:
+            return default
+    return option_get
+
+
+@dataclass
+class NodeRuntime:
+    model: ModelItem
+    instructions: str
+    allow_local_tools: bool
+    allow_remote_tools: bool
+
+
+def resolve_node_runtime(
+    *,
+    window,
+    node,
+    option_get: OptionGetter,
+    default_model: ModelItem,
+    base_prompt: Optional[str],
+    schema_allow_local: Optional[bool],
+    schema_allow_remote: Optional[bool],
+    default_allow_local: bool,
+    default_allow_remote: bool,
+) -> NodeRuntime:
+    """
+    Resolve per-node runtime using get_option() overrides, schema slots and defaults.
+
+    Priority:
+    - model:      get_option(node.id, "model") -> window.core.models.get(name) -> default_model
+    - prompt:     get_option(node.id, "prompt") -> node.instruction -> base_prompt -> ""
+    - allow_*:    get_option(node.id, "allow_local_tools"/"allow_remote_tools")
+                  -> schema flags -> defaults
+    """
+    # Model resolve
+    model_name = option_get(node.id, "model", None)
+    model_item: ModelItem = default_model
+    try:
+        if model_name:
+            cand = window.core.models.get(model_name)
+            if cand:
+                model_item = cand
+    except Exception:
+        # fallback to default_model
+        model_item = default_model
+
+    # Instructions resolve
+    prompt_opt = option_get(node.id, "prompt", None)
+    instructions = (prompt_opt or getattr(node, "instruction", None) or base_prompt or "").strip()
+
+    # Tools flags resolve
+    allow_local_tools = bool(
+        option_get(
+            node.id,
+            "allow_local_tools",
+            schema_allow_local if schema_allow_local is not None else default_allow_local,
+        )
+    )
+    allow_remote_tools = bool(
+        option_get(
+            node.id,
+            "allow_remote_tools",
+            schema_allow_remote if schema_allow_remote is not None else default_allow_remote,
+        )
+    )
+
+    return NodeRuntime(
+        model=model_item,
+        instructions=instructions,
+        allow_local_tools=allow_local_tools,
+        allow_remote_tools=allow_remote_tools,
+    )

pygpt_net/core/agents/provider.py

@@ -6,12 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.17 19:00:00                  #
+# Updated Date: 2025.09.24 00:00:00                  #
 # ================================================== #
 
-from typing import List, Dict, Any
+import copy
+from typing import List, Dict, Any, Optional
 
-from pygpt_net.core.types import MODE_CHAT
+from pygpt_net.core.types import MODE_CHAT, MODE_AGENT_LLAMA
 from pygpt_net.item.model import ModelItem
 from pygpt_net.provider.agents.base import BaseAgent
 
@@ -25,6 +26,7 @@ class Provider:
         """
         self.window = window
         self.agents = {}
+        self.hidden = ["openai_custom", "llama_custom"]  # builder hidden agents (hide provider on list)
 
     def get_ids(self) -> List[str]:
         """
@@ -34,32 +36,90 @@ class Provider:
         """
         return list(self.agents.keys())
 
-    def has(self, id: str) -> bool:
+    def has(self, id: str, mode: str = MODE_AGENT_LLAMA) -> bool:
         """
         Check if agent exists
 
         :param id: agent id
+        :param mode: agent mode, used for custom agents (optional)
         :return: True if exists
         """
+        custom = self.get_custom(id, mode) # shared instance
+        if custom is not None:
+            return True
         return id in self.agents
 
-    def get(self, id: str) -> BaseAgent:
+    def get(self, id: str, mode: str = MODE_AGENT_LLAMA) -> BaseAgent:
         """
         Get agent provider
 
         :param id: agent id
+        :param mode: agent mode, used for custom agents (optional)
         :return: agent provider
         """
+        # custom agents
+        custom = self.get_custom(id, mode)  # shared instance
+        if custom is not None:
+            return custom
+
+        # predefined agents
         if id in self.agents:
             return self.agents[id]
 
+    def get_custom(
+            self,
+            id: str,
+            mode: str = MODE_AGENT_LLAMA,
+            as_copy: bool = True
+    ) -> Optional[BaseAgent]:
+        """
+        Get custom agent provider by id
+
+        :param id: agent id
+        :param mode: agent mode, used for custom agents (optional)
+        :param as_copy: return a copy of the agent (default: False)
+        :return: custom agent provider
+        """
+        custom = None
+        if self.window and self.window.core.agents.custom.is_custom(id):
+            try:
+                if mode == MODE_AGENT_LLAMA:
+                    if "llama_custom" in self.agents:
+                        custom = copy.deepcopy(self.agents["llama_custom"]) if as_copy else self.agents["llama_custom"]
+                else:
+                    if "openai_custom" in self.agents:
+                        custom = copy.deepcopy(self.agents["openai_custom"]) if as_copy else self.agents["openai_custom"]
+            except Exception as e:
+                self.window.core.debug.log(f"Failed to get custom agent '{id}': {e}")
+                return None
+
+        # append custom id and build options
+        if custom is not None:
+            options = self.window.core.agents.custom.build_options(id)
+            custom.set_id(id)
+            custom.set_options(options)
+        return custom
+
     def all(self) -> Dict[str, BaseAgent]:
         """
-        Get all agents
+        Get all agents (predefined + custom, for build options)
 
         :return: dict of agent providers
         """
-        return self.agents
+        all_agents = {}
+
+        # predefined agents
+        for id in self.get_ids():
+            if id in self.hidden:
+                continue
+            all_agents[id] = self.agents[id]
+
+        # custom agents
+        if self.window:
+            for id in self.window.core.agents.custom.get_ids():
+                all_agents[id] = self.get_custom(id, as_copy=True)  # copy to avoid overwriting options
+        return all_agents
+
 
     def register(self, id: str, agent):
         """
@@ -87,6 +147,8 @@ class Provider:
         """
         choices = []
         for id in self.get_ids():
+            if id in self.hidden:
+                continue
             agent = self.get(id)
             if type is not None:
                 if agent.type != type:
@@ -94,6 +156,9 @@ class Provider:
             choices.append({id: agent.name})
 
         # sort by name
+        if self.window:
+            custom = self.window.core.agents.custom.get_choices()
+            choices.extend(custom)
         choices.sort(key=lambda x: list(x.values())[0].lower())
         return choices
 

pygpt_net/core/agents/runner.py

@@ -81,7 +81,7 @@ class Runner:
 
         try:
             # first, check if agent exists
-            if not self.window.core.agents.provider.has(agent_id):
+            if not self.window.core.agents.provider.has(agent_id, context.mode):
                 raise Exception(f"Agent not found: {agent_id}")
 
             # prepare input ctx
@@ -155,6 +155,8 @@ class Runner:
                     )
                     history.insert(0, msg)
 
+            # append custom schema if available
+            schema = self.window.core.agents.custom.get_schema(agent_id)
             agent_kwargs = {
                 "context": context,
                 "tools": tools,
@@ -171,9 +173,9 @@ class Runner:
                 "are_commands": is_cmd,
                 "workdir": workdir,
                 "preset": context.preset if context else None,
+                "schema": schema,
             }
-
-            provider = self.window.core.agents.provider.get(agent_id)
+            provider = self.window.core.agents.provider.get(agent_id, context.mode)
             agent = provider.get_agent(self.window, agent_kwargs)
             agent_run = provider.run
             if verbose:
@@ -188,6 +190,8 @@ class Runner:
                 "signals": signals,
                 "verbose": verbose,
             }
+            if schema:
+                kwargs["schema"] = schema
 
             if mode == AGENT_MODE_PLAN:
                 return self.llama_plan.run(**kwargs)
@@ -291,7 +295,6 @@ class Runner:
                 "workdir": workdir,
                 "preset": context.preset if context else None,
             }
-
             provider = self.window.core.agents.provider.get(agent_id)
             agent = provider.get_agent(self.window, agent_kwargs)
             if verbose:

pygpt_net/core/agents/runners/helpers.py

@@ -100,7 +100,7 @@ class Helpers:
         """
         if signals is None:
             return
-        chunk = ctx.stream.replace("<execute>", "\n```python\n").replace("</execute>", "\n```\n")
+        chunk = ctx.stream.replace("<execute>", "\n```python\n").replace("</execute>", "\n```\n") if ctx.stream else ""
         data = {
             "meta": ctx.meta,
             "ctx": ctx,

pygpt_net/core/agents/runners/llama_workflow.py

@@ -48,6 +48,7 @@ class LlamaWorkflow(BaseRunner):
             verbose: bool = False,
             history: List[CtxItem] = None,
             llm: Any = None,
+            schema: Optional[List] = None,
     ) -> bool:
         """
         Run agent workflow
@@ -59,6 +60,7 @@ class LlamaWorkflow(BaseRunner):
         :param verbose: verbose mode
         :param history: chat history
         :param llm: LLM instance
+        :param schema: custom agent flow schema
         :return: True if success
         """
         if self.is_stopped():
@@ -253,6 +255,7 @@ class LlamaWorkflow(BaseRunner):
         item_ctx.stream = ""  # for stream
 
         async for event in handler.stream_events():
+            print(event)
             if self.is_stopped():
                 # persist current output on stop
                 item_ctx.output = item_ctx.live_output

pygpt_net/core/agents/runners/openai_workflow.py

@@ -9,7 +9,7 @@
 # Updated Date: 2025.08.24 03:00:00                  #
 # ================================================== #
 
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 
 from pygpt_net.core.bridge.context import BridgeContext
 from pygpt_net.core.bridge.worker import BridgeSignals
@@ -18,6 +18,7 @@ from pygpt_net.item.ctx import CtxItem
 
 from ..bridge import ConnectionContext
 from .base import BaseRunner
+from ..custom.logging import StdLogger
 
 
 class OpenAIWorkflow(BaseRunner):
@@ -41,6 +42,7 @@ class OpenAIWorkflow(BaseRunner):
             verbose: bool = False,
             history: List[CtxItem] = None,
             stream: bool = False,
+            schema: Optional[List] = None,
     ) -> bool:
         """
         Run OpenAI agents
@@ -54,6 +56,7 @@ class OpenAIWorkflow(BaseRunner):
         :param verbose: verbose mode
         :param history: chat history
         :param stream: use streaming
+        :param schema: custom agent flow schema
         :return: True if success
         """
         if self.is_stopped():
@@ -193,6 +196,10 @@ class OpenAIWorkflow(BaseRunner):
         if previous_response_id:
             run_kwargs["previous_response_id"] = previous_response_id
 
+        # custom agent schema
+        if schema:
+            run_kwargs["schema"] = schema
+
         # split response messages to separated context items
         run_kwargs["use_partial_ctx"] = self.window.core.config.get("agent.openai.response.split", True)
 

pygpt_net/core/filesystem/parser.py

@@ -26,28 +26,44 @@ class Parser:
 
     def extract_data_paths(self, text: str) -> list:
         """
-        Extract file paths from text that contain 'data' segment.
-
-        :param text: input text
-        :return: list of file paths containing 'data' segment
+        Extract file paths from text that contain 'data' segment (case-insensitive).
+        Supports quoted and unquoted paths, POSIX/Windows, and ignores URLs.
         """
-        if text is None:
+        if not text:
             return []
-        path_pattern = r"(?:[A-Za-z]:)?(?:[\\/][^\s'\";]+)+"
-        candidates = re.findall(path_pattern, text)
-        filtered = [
-            p for p in candidates
-            if re.search(r"(?:^|[\\/])data(?:[\\/]|$)", p)
-        ]
-        return filtered
-
-    def extract_data_files(self, ctx: CtxItem, response: str) -> list:
+
+        def is_data_path(p: str) -> bool:
+            # 'data' (case-insensitive)
+            return re.search(r"(?i)(?:^|[\\/])data(?:[\\/]|$)", p) is not None
+
+        def is_url(p: str) -> bool:
+            return re.match(r"^[a-z][a-z0-9+.-]*://", p, re.I) is not None
+
+        results = []
+
+        quoted_pat = re.compile(r"(?P<q>['\"])(?P<p>(?:[A-Za-z]:)?[\\/](?:(?!\1).)+?)\1")
+        for m in quoted_pat.finditer(text):
+            p = m.group("p").strip()
+            if not is_url(p) and is_data_path(p):
+                results.append(p)
+
+        unquoted_pat = re.compile(r"(?P<p>(?:[A-Za-z]:)?(?:[\\/][^\s'\"),;]+)+)")
+        for m in unquoted_pat.finditer(text):
+            p = m.group("p").strip()
+            if not is_url(p) and is_data_path(p):
+                results.append(p)
+
+        seen = set()
+        out = []
+        for p in results:
+            if p not in seen:
+                seen.add(p)
+                out.append(p)
+        return out
+
+    def extract_data_files(self, ctx: "CtxItem", response: str) -> list:
         """
         Extract files from tool outputs and return list of file paths.
-
-        :param ctx: CtxItem
-        :param response: response text containing file paths
-        :return: list of file paths
         """
         if response is None:
             return []
@@ -58,14 +74,11 @@ class Parser:
         def replace_with_local(path):
             """
             Replace the path with local data directory path.
-
-            :param path: original path
-            :return: modified path
             """
             segments = re.split(r"[\\/]+", path)
-            try:
-                data_index = segments.index("data")
-            except ValueError:
+            # case-insensitive find of 'data'
+            data_index = next((i for i, s in enumerate(segments) if s.lower() == "data"), None)
+            if data_index is None:
                 return path
             tail = segments[data_index + 1:]
             new_path = os.path.join(local_data_dir, *tail) if tail else local_data_dir

pygpt_net/{ui/widget/builder → core/node_editor}/__init__.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.19 00:00:00                  #
+# Updated Date: 2025.09.24 00:00:00                  #
 # ================================================== #
 
-from .editor import NodeEditor
+from .graph import NodeGraph