pygpt-net 2.6.59__py3-none-any.whl → 2.6.61__py3-none-any.whl

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,100 @@
+#!/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.25 14: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.
+    """
+    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, Any],
+        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 []
+
+        # Prefer FunctionAgent if the underlying LLM supports function-calling (recommended by LI).
+        # This yields more direct compliance with system_prompt for simple single-output tasks.
+        is_fc_model = False
+        try:
+            is_fc_model = bool(getattr(getattr(llm, "metadata", None), "is_function_calling_model", False))
+        except Exception:
+            is_fc_model = False
+
+        if multi_output:
+            agent_cls = FunctionAgent  # routers: keep JSON compliance
+        else:
+            agent_cls = FunctionAgent if is_fc_model else ReActAgent
+
+        kwargs: Dict[str, Any] = {
+            "name": agent_name,
+            "system_prompt": instr,
+            "llm": llm,
+            "chat_history": chat_history or [],
+            "max_iterations": int(max_iterations),
+            # Provide a short description to reinforce the agent's purpose (if role present).
+            "description": (node_runtime.role or agent_name),
+        }
+        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}, "
+            f"routes={allowed_routes}, agent_cls={agent_cls.__name__}"
+        )
+        return BuiltAgentLI(
+            instance=instance,
+            name=agent_name,
+            instructions=instr,
+            multi_output=multi_output,
+            allowed_routes=allowed_routes,
+        )

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

@@ -0,0 +1,106 @@
+#!/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 json
+import re
+from typing import Optional
+
+
+class DelayedRouterStreamerLI:
+    """Collect raw JSON stream (no UI)."""
+    def __init__(self):
+        self._raw = ""
+    def reset(self):
+        self._raw = ""
+    def handle_delta(self, delta: str):
+        self._raw += delta or ""
+    @property
+    def buffer(self) -> str:
+        return self._raw
+
+
+class RealtimeRouterStreamerLI:
+    """
+    Stream only JSON 'content' string incrementally.
+    handle_delta(delta) -> returns decoded content suffix to emit (may be '').
+    """
+    CONTENT_PATTERN = re.compile(r'"content"\s*:\s*"')
+
+    def __init__(self):
+        self._raw = ""
+        self._content_started = False
+        self._content_closed = False
+        self._content_start_idx = -1
+        self._content_raw = ""
+        self._content_decoded = ""
+
+    def reset(self):
+        self._raw = ""
+        self._content_started = False
+        self._content_closed = False
+        self._content_start_idx = -1
+        self._content_raw = ""
+        self._content_decoded = ""
+
+    def handle_delta(self, delta: str) -> str:
+        if not delta:
+            return ""
+        self._raw += delta
+        if not self._content_started:
+            m = self.CONTENT_PATTERN.search(self._raw)
+            if m:
+                self._content_started = True
+                self._content_start_idx = m.end()
+            else:
+                return ""
+        if self._content_started and not self._content_closed:
+            return self._process()
+        return ""
+
+    def _process(self) -> str:
+        sub = self._raw[self._content_start_idx:]
+        close_idx = self._find_unescaped_quote(sub)
+        if close_idx is not None:
+            portion = sub[:close_idx]
+            self._content_closed = True
+        else:
+            portion = sub
+        new_raw_piece = portion[len(self._content_raw):]
+        if not new_raw_piece:
+            return ""
+        self._content_raw += new_raw_piece
+        try:
+            decoded_full = json.loads(f'"{self._content_raw}"')
+            new_suffix = decoded_full[len(self._content_decoded):]
+            self._content_decoded = decoded_full
+            return new_suffix
+        except Exception:
+            return ""
+
+    @staticmethod
+    def _find_unescaped_quote(s: str) -> Optional[int]:
+        i = 0
+        while i < len(s):
+            if s[i] == '"':
+                j = i - 1
+                bs = 0
+                while j >= 0 and s[j] == '\\':
+                    bs += 1
+                    j -= 1
+                if bs % 2 == 0:
+                    return i
+            i += 1
+        return None
+
+    @property
+    def buffer(self) -> str:
+        return self._raw