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

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

@@ -0,0 +1,253 @@
+#!/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, Callable, Dict, List, Optional, Union
+
+from agents import TResponseInputItem
+from pygpt_net.item.model import ModelItem
+from pygpt_net.item.preset import PresetItem
+
+try:
+    from llama_index.core.llms import ChatMessage, MessageRole
+    from llama_index.core.tools import BaseTool, FunctionTool
+    from llama_index.core.llms.llm import LLM
+except Exception:
+    ChatMessage = None
+    MessageRole = None
+    BaseTool = object  # type: ignore
+    FunctionTool = None
+    LLM = object  # type: ignore
+
+OptionGetter = Callable[[str, str, Any], Any]
+
+
+def make_option_getter(base_agent, preset: Optional[PresetItem]) -> OptionGetter:
+    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
+    role: Optional[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:
+    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:
+        model_item = default_model
+
+    prompt_opt = option_get(node.id, "prompt", None)
+    instructions = (prompt_opt or getattr(node, "instruction", None) or base_prompt or "").strip()
+
+    # Role resolve (optional)
+    role_opt = option_get(node.id, "role", None)
+    role_from_schema = getattr(node, "role", None) if hasattr(node, "role") else None
+    role: Optional[str] = None
+    if isinstance(role_opt, str) and role_opt.strip():
+        role = role_opt.strip()
+    elif isinstance(role_from_schema, str) and role_from_schema.strip():
+        role = role_from_schema.strip()
+
+    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,
+        role=role,
+        allow_local_tools=allow_local_tools,
+        allow_remote_tools=allow_remote_tools,
+    )
+
+
+def sanitize_input_items(items: List[TResponseInputItem]) -> List[TResponseInputItem]:
+    sanitized: List[TResponseInputItem] = []
+    for it in items or []:
+        if isinstance(it, dict):
+            new_it: Dict[str, Any] = dict(it)
+            new_it.pop("id", None)
+            new_it.pop("message_id", None)
+            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 content_to_str(content: Union[str, List[Dict[str, Any]], None]) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        out: List[str] = []
+        for part in content:
+            if isinstance(part, dict) and "text" in part:
+                out.append(str(part["text"]))
+        return "\n".join(out)
+    return ""
+
+
+def to_li_chat_messages(items: List[TResponseInputItem]) -> List[ChatMessage]:
+    if ChatMessage is None or MessageRole is None:
+        return []
+    msgs: List[ChatMessage] = []
+    for it in items or []:
+        if not isinstance(it, dict):
+            continue
+        role = str(it.get("role", "")).lower()
+        text = content_to_str(it.get("content"))
+        if not text:
+            continue
+        if role == "user":
+            msgs.append(ChatMessage(role=MessageRole.USER, content=text))
+        elif role == "assistant":
+            msgs.append(ChatMessage(role=MessageRole.ASSISTANT, content=text))
+        elif role == "system":
+            msgs.append(ChatMessage(role=MessageRole.SYSTEM, content=text))
+        else:
+            msgs.append(ChatMessage(role=MessageRole.USER, content=text))
+    return msgs
+
+
+def single_user_msg(text: str) -> List[ChatMessage]:
+    if ChatMessage is None or MessageRole is None:
+        return []
+    return [ChatMessage(role=MessageRole.USER, content=text or "")]
+
+
+def coerce_li_tools(function_tools: List[Any]) -> List[Any]:
+    if BaseTool is object:
+        return []
+    tools_out: List[Any] = []
+    for t in function_tools or []:
+        try:
+            if isinstance(t, BaseTool):
+                tools_out.append(t)
+            elif callable(t) and FunctionTool is not None:
+                tools_out.append(FunctionTool.from_defaults(t))
+            elif isinstance(t, dict):
+                fn = t.get("fn") or t.get("callable")
+                if callable(fn) and FunctionTool is not None:
+                    tools_out.append(FunctionTool.from_defaults(fn))
+        except Exception:
+            continue
+    return tools_out
+
+
+def resolve_llm(window, node_model: ModelItem, base_llm: Any, stream: bool) -> Any:
+    """
+    Best practice in your app: if per-node model set -> window.core.idx.llm.get(model, stream),
+    else reuse the base_llm provided from the app.
+    """
+    try:
+        if node_model and hasattr(node_model, "name") and getattr(window.core, "idx", None):
+            return window.core.idx.llm.get(node_model, stream=stream)
+    except Exception:
+        pass
+    return base_llm
+
+
+def patch_last_assistant_output(items: List[TResponseInputItem], text: str) -> List[TResponseInputItem]:
+    if not items:
+        return items
+    patched = list(items)
+    idx = 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
+    patched[idx] = {"role": "assistant", "content": [{"type": "output_text", "text": text or ""}]}
+    return sanitize_input_items(patched)
+
+def extract_agent_text(ret: Any) -> str:
+    """
+    Extract plain text from various LlamaIndex agent return types.
+    Prefer ret.response.message/content/text if present; avoid str(ret) which may add 'assistant:'.
+    """
+    try:
+        resp = getattr(ret, "response", None)
+        if resp is None:
+            # Some agents return plain string
+            return str(ret or "")
+        # ChatResponse(message=LLMMessage(content=...)) or text=...
+        msg = getattr(resp, "message", None)
+        if msg is not None:
+            # LLMMessage variants
+            content = getattr(msg, "content", None) or getattr(msg, "text", None)
+            if isinstance(content, str):
+                return content
+        text = getattr(resp, "text", None)
+        if isinstance(text, str):
+            return text
+        # Fallback
+        return str(resp)
+    except Exception:
+        return str(ret or "")
+
+
+def strip_role_prefixes(text: str) -> str:
+    """
+    Remove leading 'assistant:' / 'user:' / 'system:' if leaked from stringified outputs.
+    """
+    if not text:
+        return ""
+    import re
+    return re.sub(r"^\s*(assistant|user|system)\s*:\s*", "", text.strip(), flags=re.IGNORECASE)

pygpt_net/core/agents/custom/logging.py

@@ -0,0 +1,50 @@
+#!/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 Protocol, Optional, Any
+
+
+class Logger(Protocol):
+    """Minimal logger protocol used across the flow core."""
+    def debug(self, msg: str, **kwargs: Any) -> None: ...
+    def info(self, msg: str, **kwargs: Any) -> None: ...
+    def warning(self, msg: str, **kwargs: Any) -> None: ...
+    def error(self, msg: str, **kwargs: Any) -> None: ...
+
+
+class NullLogger:
+    """No-op logger."""
+    def debug(self, msg: str, **kwargs: Any) -> None: pass
+    def info(self, msg: str, **kwargs: Any) -> None: pass
+    def warning(self, msg: str, **kwargs: Any) -> None: pass
+    def error(self, msg: str, **kwargs: Any) -> None: pass
+
+
+class StdLogger:
+    """Simple stdout logger; can be replaced by external one from your app."""
+    def __init__(self, prefix: str = "[flow]"):
+        self.prefix = prefix
+
+    def _fmt(self, level: str, msg: str) -> str:
+        return f"{self.prefix} {level.upper()}: {msg}"
+
+    def debug(self, msg: str, **kwargs: Any) -> None:
+        print(self._fmt("debug", msg))
+
+    def info(self, msg: str, **kwargs: Any) -> None:
+        print(self._fmt("info", msg))
+
+    def warning(self, msg: str, **kwargs: Any) -> None:
+        print(self._fmt("warning", msg))
+
+    def error(self, msg: str, **kwargs: Any) -> None:
+        print(self._fmt("error", msg))

pygpt_net/core/agents/custom/memory.py

@@ -0,0 +1,51 @@
+#!/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, field
+from typing import List, Optional, Dict, Any
+
+from agents import TResponseInputItem
+
+
+@dataclass
+class MemoryState:
+    """Holds conversation items and last response id for a memory node."""
+    mem_id: str
+    items: List[TResponseInputItem] = field(default_factory=list)
+    last_response_id: Optional[str] = None
+
+    def is_empty(self) -> bool:
+        return not self.items
+
+    def set_from(self, items: List[TResponseInputItem], last_response_id: Optional[str]) -> None:
+        self.items = list(items or [])
+        self.last_response_id = last_response_id
+
+    def update_from_result(self, items: List[TResponseInputItem], last_response_id: Optional[str]) -> None:
+        self.set_from(items, last_response_id)
+
+
+class MemoryManager:
+    """Manages MemoryState instances keyed by memory node id."""
+    def __init__(self) -> None:
+        self._mem: Dict[str, MemoryState] = {}
+
+    def get(self, mem_id: str) -> MemoryState:
+        if mem_id not in self._mem:
+            self._mem[mem_id] = MemoryState(mem_id=mem_id)
+        return self._mem[mem_id]
+
+    def set(self, mem_id: str, items: List[TResponseInputItem], last_response_id: Optional[str]) -> None:
+        self.get(mem_id).set_from(items, last_response_id)
+
+    def snapshot(self) -> Dict[str, MemoryState]:
+        return dict(self._mem)

pygpt_net/core/agents/custom/router.py

@@ -0,0 +1,155 @@
+#!/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
+import json
+import re
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Any, Dict
+
+
+@dataclass
+class RouteDecision:
+    route: Optional[str]  # next node id or "end"
+    content: str          # human-facing content to display
+    raw: str              # raw model output
+    valid: bool
+    error: Optional[str] = None
+
+
+def build_router_instruction(
+    agent_name: str,
+    current_id: str,
+    allowed_routes: List[str],
+    friendly_map: Dict[str, Any],
+) -> str:
+    """
+    Builds an instruction that forces the model to output JSON with next route and content.
+
+    Additionally, if the provided friendly_map contains role information for any of the
+    allowed routes (e.g. friendly_map[id] is a dict with a "role" key), these roles
+    are included in the instruction to improve routing. This is optional and included
+    only when present and non-empty.
+    """
+    allowed = ", ".join(allowed_routes)
+
+    # Normalize human-friendly names: accept either a plain string or a dict with
+    # common name keys such as "name", "title" or "label".
+    def _extract_name(val: Any, default_name: str) -> str:
+        if isinstance(val, str):
+            return val
+        if isinstance(val, dict):
+            return str(val.get("name") or val.get("title") or val.get("label") or default_name)
+        return default_name
+
+    # Extract names and optional roles for allowed routes, without changing input map semantics.
+    friendly_names = {rid: _extract_name(friendly_map.get(rid), rid) for rid in allowed_routes}
+
+    # Roles are optional; include only non-empty strings.
+    friendly_roles: Dict[str, str] = {}
+    for rid in allowed_routes:
+        val = friendly_map.get(rid)
+        role_val: Optional[str] = None
+        if isinstance(val, dict):
+            role_val = val.get("role")
+        if isinstance(role_val, str) and role_val.strip():
+            friendly_roles[rid] = role_val.strip()
+
+    # Base instruction
+    instr = (
+        "You are a routing-capable agent in a multi-agent flow.\n"
+        f"Your id is: {current_id}, name: {agent_name}.\n"
+        "You MUST respond ONLY with a single JSON object and nothing else.\n"
+        "Schema:\n"
+        '{\n'
+        '  "route": "<ID of the next agent from allowed_routes OR the string \'end\'>",\n'
+        '  "content": "<final response text for the user (or tool result)>"\n'
+        '}\n'
+        "Rules:\n"
+        f"- allowed_routes: [{allowed}]\n"
+        "- If you want to finish the flow, set route to \"end\".\n"
+        "- content must contain the user-facing answer (you may include structured data as JSON or Markdown inside content).\n"
+        "- Do NOT add any commentary outside of the JSON. No leading or trailing text.\n"
+        "- If using tools, still return the final JSON with tool results summarized in content.\n"
+        f"- Human-friendly route names: {json.dumps(friendly_names)}\n"
+    )
+
+    # Append roles only if any are present (optional).
+    if friendly_roles:
+        instr += f"- Human-friendly route roles (optional): {json.dumps(friendly_roles)}\n"
+
+    return instr
+
+
+def _extract_json_block(text: str) -> Optional[str]:
+    """
+    Extract JSON block from the text. Supports raw JSON or fenced ```json blocks.
+    """
+    # fenced block
+    m = re.search(r"```json\s*(\{.*?\})\s*```", text, flags=re.DOTALL | re.IGNORECASE)
+    if m:
+        return m.group(1).strip()
+
+    # first JSON object occurrence fallback
+    brace_idx = text.find("{")
+    if brace_idx != -1:
+        # naive attempt to find matching closing brace
+        snippet = text[brace_idx:]
+        # try to trim trailing content after last closing brace
+        last_close = snippet.rfind("}")
+        if last_close != -1:
+            return snippet[: last_close + 1].strip()
+    return None
+
+
+def parse_route_output(raw_text: str, allowed_routes: List[str]) -> RouteDecision:
+    """
+    Parse model output enforcing the {route, content} schema.
+    """
+    text = raw_text.strip()
+    candidate = text
+
+    # Try direct JSON parse
+    parsed: Optional[Any] = None
+    for attempt in range(2):
+        try:
+            parsed = json.loads(candidate)
+            break
+        except Exception:
+            if attempt == 0:
+                block = _extract_json_block(text)
+                if block:
+                    candidate = block
+                    continue
+            parsed = None
+            break
+
+    if isinstance(parsed, dict):
+        route = parsed.get("route")
+        content = parsed.get("content", "")
+        # Normalize route strings
+        if isinstance(route, str):
+            route_norm = route.strip().lower()
+            if route_norm == "end":
+                return RouteDecision(route="end", content=str(content), raw=raw_text, valid=True)
+            # exact match against allowed
+            if route in allowed_routes:
+                return RouteDecision(route=route, content=str(content), raw=raw_text, valid=True)
+        return RouteDecision(
+            route=None,
+            content=str(parsed.get("content", "")),
+            raw=raw_text,
+            valid=False,
+            error=f"Invalid or disallowed route: {route}",
+        )
+
+    # Not a valid JSON – fallback, pass through content as-is
+    return RouteDecision(route=None, content=raw_text, raw=raw_text, valid=False, error="Malformed JSON")

pygpt_net/core/agents/custom/router_streamer.py

@@ -0,0 +1,187 @@
+#!/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
+import json
+from typing import Optional, Tuple, Any
+
+from pygpt_net.core.agents.bridge import ConnectionContext
+from pygpt_net.item.ctx import CtxItem
+from pygpt_net.provider.api.openai.agents.response import StreamHandler
+
+from openai.types.responses import (
+    ResponseTextDeltaEvent,
+    ResponseCreatedEvent,
+    ResponseCompletedEvent,
+)
+
+from .logging import Logger, NullLogger
+
+
+class DelayedRouterStreamer:
+    """
+    Delayed streaming for multi-output router agents:
+    - Collect tokens silently (no UI flush).
+    - After completion, reveal only parsed `content` to UI.
+    """
+    def __init__(self, window, bridge: ConnectionContext):
+        self.window = window
+        self.bridge = bridge
+        self.handler = StreamHandler(window, bridge)
+        self._last_response_id: Optional[str] = None
+
+    def reset(self) -> None:
+        self.handler.reset()
+        self.handler.buffer = ""
+        self._last_response_id = None
+
+    def handle_event(self, event: Any, ctx: CtxItem) -> Tuple[str, Optional[str]]:
+        text, resp_id = self.handler.handle(event, ctx, flush=False, buffer=True)
+        if resp_id:
+            self._last_response_id = resp_id
+        return self.handler.buffer, self._last_response_id
+
+    @property
+    def buffer(self) -> str:
+        return self.handler.buffer
+
+    @property
+    def last_response_id(self) -> Optional[str]:
+        return self._last_response_id
+
+
+class RealtimeRouterStreamer:
+    """
+    Realtime streaming for multi-output router agents:
+    - Detect `"content": "<...>"` in streamed JSON and emit decoded content incrementally to UI.
+    - After completion, caller parses the final route from full buffer.
+    """
+    CONTENT_PATTERN = re.compile(r'"content"\s*:\s*"')
+
+    def __init__(
+        self,
+        window,
+        bridge: ConnectionContext,
+        handler: Optional[StreamHandler] = None,
+        buffer_to_handler: bool = True,
+        logger: Optional[Logger] = None,
+    ):
+        self.window = window
+        self.bridge = bridge
+        self.handler = handler
+        self.buffer_to_handler = buffer_to_handler
+        self.logger = logger or NullLogger()
+
+        self._raw: str = ""
+        self._last_response_id: Optional[str] = None
+
+        self._content_started: bool = False
+        self._content_closed: bool = False
+        self._content_start_idx: int = -1
+        self._content_raw: str = ""
+        self._content_decoded: str = ""
+
+    def reset(self) -> None:
+        self._raw = ""
+        self._last_response_id = None
+        self._content_started = False
+        self._content_closed = False
+        self._content_start_idx = -1
+        self._content_raw = ""
+        self._content_decoded = ""
+
+    def handle_event(self, event: Any, ctx: CtxItem) -> None:
+        if event.type != "raw_response_event":
+            return
+
+        data = event.data
+        if isinstance(data, ResponseCreatedEvent):
+            self._last_response_id = data.response.id
+            return
+
+        if isinstance(data, ResponseTextDeltaEvent):
+            delta = data.delta or ""
+            if not delta:
+                return
+            prev_len = len(self._raw)
+            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()
+                    self.logger.debug("[router-realtime] content field detected in stream.")
+                    if len(self._raw) > self._content_start_idx:
+                        self._process_new_content(ctx)
+                return
+
+            if self._content_started and not self._content_closed:
+                self._process_new_content(ctx)
+            return
+
+        if isinstance(data, ResponseCompletedEvent):
+            if self._content_started:
+                self.logger.debug("[router-realtime] stream completed; final JSON will be parsed by runner.")
+            return
+
+    def _process_new_content(self, ctx: CtxItem) -> None:
+        sub = self._raw[self._content_start_idx:]
+        close_idx = self._find_unescaped_quote(sub)
+        if close_idx is not None:
+            content_portion = sub[:close_idx]
+            self._content_closed = True
+            self.logger.debug("[router-realtime] content field closed in stream.")
+        else:
+            content_portion = sub
+
+        new_raw_piece = content_portion[len(self._content_raw):]
+        if not new_raw_piece:
+            return
+
+        self._content_raw += new_raw_piece
+
+        try:
+            decoded_full: str = json.loads(f'"{self._content_raw}"')
+            new_suffix = decoded_full[len(self._content_decoded):]
+            if new_suffix:
+                ctx.stream = new_suffix
+                self.bridge.on_step(ctx, False)
+                if self.handler is not None and self.buffer_to_handler:
+                    self.handler.to_buffer(new_suffix)
+                self._content_decoded = decoded_full
+        except Exception:
+            # wait for more tokens
+            pass
+
+    @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
+
+    @property
+    def last_response_id(self) -> Optional[str]:
+        return self._last_response_id