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

pygpt_net/core/agents/custom/__init__.py

@@ -0,0 +1,275 @@
+#!/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                  #
+# ================================================== #
+
+import copy
+from uuid import uuid4
+
+from pygpt_net.core.types import MODEL_DEFAULT
+from pygpt_net.item.agent import AgentItem
+from pygpt_net.item.builder_layout import BuilderLayoutItem
+from pygpt_net.provider.core.agent.json_file import JsonFileProvider
+from pygpt_net.utils import trans
+
+
+class Custom:
+
+    CUSTOM_AGENT_SUFFIX = " *"  # suffix for custom agents in lists
+
+    def __init__(self, window=None):
+        """
+        Custom agents core
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.provider = JsonFileProvider(window)  # JSON file provider
+        self.agents = {}  # dict of AgentItem
+        self.layout = None  # BuilderLayoutItem
+        self.loaded = False
+
+    def load(self):
+        """Load custom agents from provider"""
+        data = self.provider.load()
+        if "layout" in data:
+            self.layout = data["layout"]
+        if "agents" in data:
+            self.agents = data["agents"]
+        self.loaded = True
+
+    def reload(self):
+        """Reload custom agents from provider"""
+        self.loaded = False
+        self.load()
+
+    def save(self):
+        """Save custom agents to provider"""
+        self.provider.save(self.layout, self.agents)
+
+    def is_custom(self, agent_id: str) -> bool:
+        """
+        Check if agent is custom
+
+        :param agent_id: agent ID
+        :return: True if custom
+        """
+        if not self.loaded:
+            self.load()
+        return agent_id in self.agents
+
+    def update_layout(self, layout: dict):
+        """
+        Update current layout of custom agents editor
+
+        :param layout: layout dict
+        """
+        if self.layout is None:
+            self.layout = BuilderLayoutItem()
+        self.layout.data = layout
+
+    def reset(self):
+        """Reset custom agents"""
+        self.agents = {}
+        self.layout = None
+        self.loaded = False
+        self.provider.truncate()
+
+    def get_layout(self) -> dict:
+        """
+        Get layout of custom agents
+
+        :return: layout dict
+        """
+        if not self.loaded:
+            self.load()
+        return self.layout
+
+    def get_agents(self) -> dict:
+        """
+        Get custom agents
+
+        :return: dict of AgentItem
+        """
+        if not self.loaded:
+            self.load()
+        return self.agents
+
+    def get_choices(self) -> list:
+        """
+        Get custom agents choices
+
+        :return: list of dict with 'id' and 'name'
+        """
+        if not self.loaded:
+            self.load()
+        return [{agent.id: f"{agent.name}{self.CUSTOM_AGENT_SUFFIX}"} for agent in self.agents.values()]
+
+    def get_agent(self, agent_id: str):
+        """
+        Get custom agent by ID
+
+        :param agent_id: agent ID
+        :return: AgentItem or None
+        """
+        if not self.loaded:
+            self.load()
+        return self.agents.get(agent_id)
+
+    def get_ids(self) -> list:
+        """
+        Get list of custom agent IDs
+
+        :return: list of agent IDs
+        """
+        if not self.loaded:
+            self.load()
+        return list(self.agents.keys())
+
+    def get_schema(self, agent_id: str) -> list:
+        """
+        Get schema of a specific custom agent
+
+        :param agent_id: agent ID
+        :return: list with schema or empty list
+        """
+        if not self.loaded:
+            self.load()
+        agent = self.agents.get(agent_id)
+        if agent:
+            return agent.schema
+        return []
+
+    def build_options(self, agent_id: str) -> dict:
+        """
+        Build options for a specific custom agent
+
+        :param agent_id: agent ID
+        :return: dict with options or empty dict
+        """
+        if not self.loaded:
+            self.load()
+
+        agent = self.agents.get(agent_id)
+        if not agent:
+            return {}
+
+        schema = agent.schema if agent else []
+        options = {}
+        for node in schema:
+            try:
+                if "type" in node and node["type"] == "agent":
+                    if "id" in node:
+                        sub_agent_id = node["id"]
+                        tab = {
+                            "label": sub_agent_id
+                        }
+                        opts = {
+                            "model": {
+                                "label": trans("agent.option.model"),
+                                "type": "combo",
+                                "use": "models",
+                                "default": MODEL_DEFAULT,
+                            }
+                        }
+                        if "slots" in node:
+                            slots = node["slots"]
+                            if "name" in slots and slots["name"]:
+                                tab["label"] = slots["name"]
+                            if "instruction" in slots:
+                                opts["prompt"] = {
+                                    "type": "textarea",
+                                    "label": trans("agent.option.prompt"),
+                                    "default": slots["instruction"],
+                                }
+                            if "remote_tools" in slots:
+                                opts["allow_remote_tools"] = {
+                                    "type": "bool",
+                                    "label": trans("agent.option.tools.remote"),
+                                    "description": trans("agent.option.tools.remote.desc"),
+                                    "default": slots["remote_tools"],
+                                }
+                            if "local_tools" in slots:
+                                opts["allow_local_tools"] = {
+                                    "type": "bool",
+                                    "label": trans("agent.option.tools.local"),
+                                    "description": trans("agent.option.tools.local.desc"),
+                                    "default": slots["local_tools"],
+                                }
+                        tab["options"] = opts
+                        options[sub_agent_id] = tab
+            except Exception as e:
+                self.window.core.debug.log(f"Failed to build options for custom agent '{agent_id}': {e}")
+                continue
+        return options
+
+    def new_agent(self, name: str):
+        """
+        Create new custom agent
+
+        :param name: agent name
+        """
+        if not self.loaded:
+            self.load()
+        new_id = str(uuid4())
+        new_agent = AgentItem()
+        new_agent.id = new_id
+        new_agent.name = name
+        self.agents[new_id] = new_agent
+        self.save()
+        return new_id
+
+    def duplicate_agent(self, agent_id: str, new_name: str):
+        """
+        Duplicate custom agent
+
+        :param agent_id: agent ID
+        :param new_name: new agent name
+        """
+        if not self.loaded:
+            self.load()
+        agent = self.agents.get(agent_id)
+        if agent:
+            new_agent = copy.deepcopy(agent)
+            new_agent.id = str(uuid4())
+            new_agent.name = new_name
+            self.agents[new_agent.id] = new_agent
+            self.save()
+
+    def delete_agent(self, agent_id: str):
+        """
+        Delete custom agent
+
+        :param agent_id: agent ID
+        """
+        if not self.loaded:
+            self.load()
+        if agent_id in self.agents:
+            del self.agents[agent_id]
+            self.save()
+
+    def update_agent(self, agent_id: str, layout: dict, schema: list):
+        """
+        Update layout and schema of a specific custom agent
+
+        :param agent_id: agent ID
+        :param layout: dictionary with new layout
+        :param schema: list with new schema
+        """
+        if not self.loaded:
+            self.load()
+        agent = self.agents.get(agent_id)
+        if agent:
+            if layout is None:
+                layout = {}
+            if schema is None:
+                schema = []
+            agent.layout = layout
+            agent.schema = schema
+            self.save()

pygpt_net/core/agents/custom/debug.py

@@ -0,0 +1,64 @@
+#!/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 typing import Any, List, Optional
+
+from agents import TResponseInputItem
+
+
+def ellipsize(text: str, limit: int = 280) -> str:
+    """Shorten text for logs."""
+    if text is None:
+        return ""
+    s = str(text).replace("\n", " ").replace("\r", " ")
+    return s if len(s) <= limit else s[: max(0, limit - 3)] + "..."
+
+
+def content_to_text(content: Any) -> str:
+    """Convert 'content' which may be str or list[dict] to plain text for logs."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        out: List[str] = []
+        for part in content:
+            if isinstance(part, dict):
+                if "text" in part and isinstance(part["text"], str):
+                    out.append(part["text"])
+                elif part.get("type") in ("output_text", "input_text") and "text" in part:
+                    out.append(str(part["text"]))
+                else:
+                    # fallback – best-effort stringify
+                    t = part.get("text") or ""
+                    out.append(str(t))
+            else:
+                out.append(str(part))
+        return " ".join(out)
+    return str(content or "")
+
+
+def items_preview(items: List[TResponseInputItem], total_chars: int = 280, max_items: int = 4) -> str:
+    """
+    Produce compact preview of last N messages with roles and truncated content.
+    """
+    if not items:
+        return "(empty)"
+    pick = items[-max_items:]
+    per = max(32, total_chars // max(1, len(pick)))
+    lines: List[str] = []
+    for it in pick:
+        if not isinstance(it, dict):
+            lines.append(ellipsize(str(it), per))
+            continue
+        role = it.get("role", "?")
+        text = content_to_text(it.get("content"))
+        lines.append(f"- {role}: {ellipsize(text, per)}")
+    return " | ".join(lines)

pygpt_net/core/agents/custom/factory.py

@@ -0,0 +1,109 @@
+#!/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, Dict, List, Optional
+
+from agents import Agent as OpenAIAgent
+from pygpt_net.item.preset import PresetItem
+from pygpt_net.core.bridge import BridgeContext
+from pygpt_net.provider.api.openai.agents.remote_tools import append_tools
+from pygpt_net.provider.api.openai.agents.experts import get_experts
+
+from .schema import AgentNode
+from .router import build_router_instruction
+from .utils import NodeRuntime
+
+
+@dataclass
+class BuiltAgent:
+    instance: OpenAIAgent
+    name: str
+    instructions: str
+    multi_output: bool
+    allowed_routes: List[str]
+
+
+class AgentFactory:
+    """
+    Builds OpenAIAgent instances from AgentNode + NodeRuntime.
+    """
+    def __init__(self, window, logger) -> None:
+        self.window = window
+        self.logger = logger
+
+    def build(
+        self,
+        node: AgentNode,
+        node_runtime: NodeRuntime,
+        preset: Optional[PresetItem],
+        function_tools: List[dict],
+        force_router: bool,
+        friendly_map: Dict[str, str],
+        handoffs_enabled: bool = True,
+        context: Optional[BridgeContext] = None,
+    ) -> BuiltAgent:
+        # Agent name
+        agent_name = (node.name or "").strip() or (preset.name if preset else f"Agent {node.id}")
+
+        # Multi-output routing instruction injection
+        multi_output = force_router or (len(node.outputs or []) > 1)
+        allowed_routes = list(node.outputs or [])
+
+        instr = node_runtime.instructions
+        if multi_output and allowed_routes:
+            router_instr = build_router_instruction(agent_name, node.id, allowed_routes, friendly_map)
+            instr = router_instr + "\n\n" + instr if instr else router_instr
+
+        # Base kwargs
+        kwargs: Dict[str, Any] = {
+            "name": agent_name,
+            "instructions": instr,
+            "model": self.window.core.agents.provider.get_openai_model(node_runtime.model),
+        }
+
+        # Tools
+        tool_kwargs = append_tools(
+            tools=function_tools or [],
+            window=self.window,
+            model=node_runtime.model,
+            preset=preset,
+            allow_local_tools=node_runtime.allow_local_tools,
+            allow_remote_tools=node_runtime.allow_remote_tools,
+        )
+        kwargs.update(tool_kwargs)
+
+        # Experts/handoffs if any
+        if handoffs_enabled:
+            experts = get_experts(
+                window=self.window,
+                preset=preset,
+                verbose=False,
+                tools=function_tools or [],
+            )
+            if experts:
+                kwargs["handoffs"] = experts
+
+        # Build instance
+        instance = OpenAIAgent(**kwargs)
+        self.logger.debug(
+            f"Built agent {node.id} ({agent_name}), "
+            f"multi_output={multi_output}, routes={allowed_routes}, model={node_runtime.model.name}"
+        )
+
+        return BuiltAgent(
+            instance=instance,
+            name=agent_name,
+            instructions=instr,
+            multi_output=multi_output,
+            allowed_routes=allowed_routes,
+        )

pygpt_net/core/agents/custom/graph.py

@@ -0,0 +1,71 @@
+#!/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
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from .schema import FlowSchema, AgentNode, StartNode, EndNode, MemoryNode
+
+
+@dataclass
+class FlowGraph:
+    schema: FlowSchema
+    adjacency: Dict[str, List[str]] = field(default_factory=dict)  # node_id -> list of node_ids
+    agent_to_memory: Dict[str, Optional[str]] = field(default_factory=dict)  # agent_id -> mem_id or None
+    start_targets: List[str] = field(default_factory=list)  # immediate next nodes from start
+    end_nodes: List[str] = field(default_factory=list)  # ids of end nodes
+
+    def get_next(self, node_id: str) -> List[str]:
+        return self.adjacency.get(node_id, [])
+
+    def first_connected_end(self, node_id: str) -> Optional[str]:
+        outs = self.get_next(node_id)
+        for out in outs:
+            if out in self.schema.ends:
+                return out
+        return None
+
+    def pick_default_start_agent(self) -> Optional[str]:
+        """Pick lowest numeric agent id if no start is present."""
+        if not self.schema.agents:
+            return None
+        # Prefer numeric suffix; fallback to lexicographic
+        def key_fn(aid: str) -> Tuple[int, str]:
+            m = re.search(r"(\d+)$", aid)
+            if m:
+                try:
+                    return (int(m.group(1)), aid)
+                except Exception:
+                    pass
+            return (10**9, aid)
+
+        return sorted(self.schema.agents.keys(), key=key_fn)[0]
+
+
+def build_graph(fs: FlowSchema) -> FlowGraph:
+    g = FlowGraph(schema=fs)
+    # adjacency from agents
+    for aid, anode in fs.agents.items():
+        g.adjacency[aid] = list(anode.outputs or [])
+        g.agent_to_memory[aid] = anode.memory_out
+
+    # adjacency from start nodes
+    g.end_nodes = list(fs.ends.keys())
+    g.start_targets = []
+    if fs.starts:
+        # By spec there can be multiple start nodes; we concatenate their outputs in order found
+        for sid, snode in fs.starts.items():
+            g.adjacency[sid] = list(snode.outputs or [])
+            g.start_targets.extend(snode.outputs or [])
+
+    return g

pygpt_net/core/agents/custom/llama_index/__init__.py

@@ -0,0 +1,10 @@
+#!/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                  #
+# ================================================== #

pygpt_net/core/agents/custom/llama_index/factory.py

@@ -0,0 +1,89 @@
+#!/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, Dict, List
+
+from llama_index.core.agent.workflow import ReActAgent, FunctionAgent
+
+from ..schema import AgentNode
+from ..router import build_router_instruction
+from .utils import NodeRuntime, coerce_li_tools
+
+
+@dataclass
+class BuiltAgentLI:
+    instance: Any
+    name: str
+    instructions: str
+    multi_output: bool
+    allowed_routes: List[str]
+
+
+class AgentFactoryLI:
+    """
+    Build LlamaIndex ReActAgent/FunctionAgent from AgentNode + NodeRuntime and explicit LLM/tools.
+    Best practice: chat_history/max_iterations przekazujemy do konstruktora agenta.
+    """
+    def __init__(self, window, logger) -> None:
+        self.window = window
+        self.logger = logger
+
+    def build(
+        self,
+        *,
+        node: AgentNode,
+        node_runtime: NodeRuntime,
+        llm: Any,                 # LLM instance (z appki lub resolve_llm)
+        tools: List[Any],         # BaseTool list
+        friendly_map: Dict[str, str],
+        force_router: bool = False,
+        chat_history: List[Any] = None,
+        max_iterations: int = 10,
+    ) -> BuiltAgentLI:
+        agent_name = (node.name or "").strip() or f"Agent {node.id}"
+
+        multi_output = force_router or (len(node.outputs or []) > 1)
+        allowed_routes = list(node.outputs or [])
+
+        instr = node_runtime.instructions
+        if multi_output and allowed_routes:
+            router_instr = build_router_instruction(agent_name, node.id, allowed_routes, friendly_map)
+            instr = router_instr + "\n\n" + instr if instr else router_instr
+
+        node_tools = tools if (node_runtime.allow_local_tools or node_runtime.allow_remote_tools) else []
+
+        if multi_output:
+            agent_cls = FunctionAgent  # routers behave better with FunctionAgent (JSON compliance)
+        else:
+            agent_cls = FunctionAgent if node_tools else ReActAgent
+        kwargs: Dict[str, Any] = {
+            "name": agent_name,
+            "system_prompt": instr,
+            "llm": llm,
+            "chat_history": chat_history or [],
+            "max_iterations": int(max_iterations),
+        }
+        if node_tools:
+            kwargs["tools"] = coerce_li_tools(node_tools)
+
+        instance = agent_cls(**kwargs)
+        self.logger.debug(
+            f"[li] Built agent {node.id} ({agent_name}), multi_output={multi_output}, routes={allowed_routes}"
+        )
+        return BuiltAgentLI(
+            instance=instance,
+            name=agent_name,
+            instructions=instr,
+            multi_output=multi_output,
+            allowed_routes=allowed_routes,
+        )