pygpt-net 2.7.6__py3-none-any.whl → 2.7.8__py3-none-any.whl

pygpt_net/provider/api/x_ai/realtime/realtime.py

@@ -0,0 +1,198 @@
+#!/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: 2026.01.06 20:00:00                  #
+# ================================================== #
+
+import json
+from typing import Optional, Dict, Any
+
+from pygpt_net.core.bridge import BridgeContext
+from pygpt_net.core.events import RealtimeEvent
+from pygpt_net.core.realtime.options import RealtimeOptions
+from pygpt_net.core.realtime.shared.session import extract_last_session_id
+from pygpt_net.item.model import ModelItem
+from pygpt_net.utils import trans
+
+from .client import xAIIRealtimeClient
+
+class Realtime:
+
+    PROVIDER = "x_ai"
+
+    def __init__(self, window=None):
+        """
+        OpenAI API realtime controller
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.handler = xAIIRealtimeClient(window)
+        self.prev_auto_turn = False
+        self.prev_vad_silence = 2000
+        self.prev_vad_prefix = 300
+
+    def begin(
+            self,
+            context: BridgeContext,
+            model: Optional[ModelItem] = None,
+            extra: Optional[Dict[str, Any]] = None,
+            rt_signals=None
+    ) -> bool:
+        """
+        Begin realtime session if applicable
+
+        :param context: BridgeContext
+        :param model: Optional[ModelItem]
+        :param extra: Optional dict with extra parameters
+        :param rt_signals: RealtimeSignals
+        :return: True if realtime session started, False otherwise
+        """
+        mm = context.multimodal_ctx
+        audio_bytes = getattr(mm, "audio_data", None) if mm and getattr(mm, "is_audio_input", False) else None
+        audio_format = getattr(mm, "audio_format", None) if mm else None
+        audio_rate = getattr(mm, "audio_rate", None) if mm else None
+        is_debug = self.window.core.config.get("log.realtime", False)
+        auto_turn = self.window.core.config.get("audio.input.auto_turn", True)
+        opt_vad_silence = self.window.core.config.get("audio.input.vad.silence", 2000)
+        opt_vad_prefix = self.window.core.config.get("audio.input.vad.prefix", 300)
+
+        # setup manager
+        self.window.controller.realtime.set_current_active(self.PROVIDER)
+        self.window.controller.realtime.set_busy()
+        self.handler.set_debug(is_debug)
+
+        # tools
+        tools = []
+        '''
+        tools = self.window.core.api.xai.tools.prepare(model, context.external_functions)
+        '''
+
+        # remote tools
+        remote_tools = []
+        '''
+        remote_tools = self.window.core.api.openai.remote_tools.append_to_tools(
+            mode=context.mode,
+            model=model,
+            stream=context.stream,
+            is_expert_call=context.is_expert_call,
+            tools=remote_tools,
+            preset=context.preset,
+        )
+        '''
+
+        # handle sub-reply (tool results from tool calls)
+        if context.ctx.internal:
+            if context.ctx.prev_ctx and context.ctx.prev_ctx.extra.get("prev_tool_calls"):
+                tool_calls = context.ctx.prev_ctx.extra.get("prev_tool_calls", [])
+                tool_call_id = None
+                if isinstance(tool_calls, list) and len(tool_calls) > 0:
+                    tool_call_id = tool_calls[0].get("call_id", "")  # get first call_id
+                    if not tool_call_id:
+                        tool_call_id = tool_calls[0].get("id", "")  # fallback to id
+                if tool_call_id:
+                    tool_results = context.ctx.input
+                    try:
+                        tool_results = json.loads(tool_results)
+                    except Exception:
+                        pass
+                    self.handler.send_tool_results_sync({
+                        tool_call_id: tool_results
+                    })
+                    self.handler.update_ctx(context.ctx)
+                    return True  # do not start new session, just send tool results
+
+        # update auto-turn in active session
+        if (self.handler.is_session_active()
+                and (auto_turn != self.prev_auto_turn
+                     or opt_vad_silence != self.prev_vad_silence
+                     or opt_vad_prefix != self.prev_vad_prefix)):
+            self.handler.update_session_autoturn_sync(auto_turn, opt_vad_silence, opt_vad_prefix)
+
+        # if auto-turn is enabled and prompt is empty, update session and context only
+        if auto_turn and self.handler.is_session_active() and (context.prompt.strip() == "" or context.prompt == "..."):
+            self.handler.update_session_tools_sync(tools, remote_tools)
+            self.handler.update_ctx(context.ctx)
+            self.window.update_status(trans("speech.listening"))
+            return True # do not send new request if session is active
+
+        # Last session ID
+        last_session_id = extract_last_session_id(context.history)
+        if is_debug:
+            print("[realtime session] Last ID", last_session_id)
+
+        # Voice
+        voice = "ara"
+        try:
+            v = self.window.core.plugins.get_option("audio_output", "xai_tts_voice")
+            if v:
+                voice = str(v)
+        except Exception:
+            pass
+
+        # Options
+        opts = RealtimeOptions(
+            provider=self.PROVIDER,
+            model=context.model.id,
+            system_prompt=context.system_prompt,
+            prompt=context.prompt,
+            voice=voice,
+            audio_data=audio_bytes,
+            audio_format=audio_format,
+            audio_rate=audio_rate,
+            vad="server_vad",
+            extra=extra or {},
+            tools=tools,
+            remote_tools=remote_tools,
+            rt_signals=rt_signals,
+            rt_session_id=last_session_id,
+            auto_turn=auto_turn,
+            vad_end_silence_ms=opt_vad_silence,
+            vad_prefix_padding_ms=opt_vad_prefix,
+        )
+
+        # Start or append to realtime session via manager
+        try:
+            if is_debug:
+                print("[realtime] Starting session with options:", opts.to_dict())
+            rt = self.window.controller.realtime.manager
+            rt.start(context.ctx, opts)
+
+            self.prev_auto_turn = auto_turn
+            self.prev_vad_silence = opt_vad_silence
+            self.prev_vad_prefix = opt_vad_prefix
+            return True
+        except Exception as e:
+            self.window.core.debug.log(e)
+            return False  # fallback to non-live path
+
+    def handle_audio_input(self, event: RealtimeEvent):
+        """
+        Handle Realtime audio input event
+
+        :param event: RealtimeEvent
+        """
+        self.handler.rt_handle_audio_input_sync(event)
+
+    def manual_commit(self):
+        """Manually commit audio input to realtime session"""
+        self.handler.force_response_now_sync()
+
+    def shutdown(self):
+        """Shutdown realtime loops"""
+        if self.handler.is_session_active():
+            self.handler.close_session_sync()
+        try:
+            self.handler.stop_loop_sync()
+        except Exception:
+            pass
+
+    def reset(self):
+        """Close realtime session"""
+        if self.handler.is_session_active():
+            self.handler.close_session_sync()

pygpt_net/provider/api/x_ai/{remote.py → remote_tools.py}

@@ -6,27 +6,194 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.17 20:00:00                  #
+# Updated Date: 2026.01.06 18:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
+
+import json
 from typing import Optional, Dict, Any, List
 
 from pygpt_net.item.model import ModelItem
 
+# xAI server-side tools
+try:
+    from xai_sdk.tools import web_search as x_web_search
+    from xai_sdk.tools import x_search as x_x_search
+    from xai_sdk.tools import code_execution as x_code_execution
+    from xai_sdk.tools import mcp as x_mcp
+    from xai_sdk.tools import collections_search as x_collections_search
+except Exception:
+    x_web_search = None
+    x_x_search = None
+    x_code_execution = None
+    x_mcp = None
+
 
 class Remote:
     def __init__(self, window=None):
         """
-        Live Search builder for xAI:
+        Live Search builder for xAI (old, grok-3):
         - Returns a dict with 'sdk' (X-only toggle) and 'http' (full search_parameters).
         - SDK path: native streaming (xai_sdk.chat.stream()) works only for basic X search (no advanced filters).
         - HTTP path: full Live Search (web/news/rss/X with filters), streaming via SSE.
 
+        Server-side Tools builder for xAI (newer SDKs, Responses API):
+        - Builds xAI SDK tool objects for web_search, x_search, code_execution, MCP.
+        - Returns include flags, max_turns and use_encrypted_content settings.
+
         :param window: Window instance
         """
         self.window = window
 
+    def build_for_chat(self, model: ModelItem = None, stream: bool = False) -> Dict[str, Any]:
+        """
+        Build server-side tools and options for Chat Responses.
+
+        Returns:
+            {
+              "tools": [ ... xai_sdk.tools.* ... ],
+              "include": [ ... ],
+              "use_encrypted_content": bool,
+              "max_turns": Optional[int],
+            }
+        """
+        cfg = self.window.core.config
+        include: List[str] = []
+        tools: List[object] = []
+
+        # global remote tools switch
+        is_web_enabled = self.window.controller.chat.remote_tools.enabled(model, "web_search")
+        is_x_enabled = bool(cfg.get("remote_tools.xai.x_search", False))
+        is_code_enabled = bool(cfg.get("remote_tools.xai.code_execution", False))
+        is_mcp_enabled = bool(cfg.get("remote_tools.xai.mcp", False))
+
+        # include flags
+        if stream:
+            include.append("verbose_streaming")
+        if bool(cfg.get("remote_tools.xai.inline_citations", True)):
+            include.append("inline_citations")
+        if bool(cfg.get("remote_tools.xai.include_code_output", True)):
+            include.append("code_execution_call_output")
+
+        # use_encrypted_content
+        use_encrypted = bool(cfg.get("remote_tools.xai.use_encrypted_content", False))
+
+        # optional max_turns
+        max_turns = None
+        try:
+            mt = cfg.get("remote_tools.xai.max_turns")
+            if isinstance(mt, int) and mt > 0:
+                max_turns = int(mt)
+        except Exception:
+            pass
+
+        # WEB SEARCH
+        if is_web_enabled and x_web_search is not None:
+            kwargs: Dict[str, Any] = {}
+            enable_img = bool(cfg.get("remote_tools.xai.web.enable_image_understanding", False))
+            '''
+            allowed = self._as_list(cfg.get("remote_tools.xai.web.allowed_websites"), 5)
+            excluded = self._as_list(cfg.get("remote_tools.xai.web.excluded_websites"), 5)
+            if allowed and not excluded:
+                kwargs["allowed_domains"] = allowed
+            elif excluded and not allowed:
+                kwargs["excluded_domains"] = excluded
+            '''
+            if enable_img:
+                kwargs["enable_image_understanding"] = True
+            try:
+                tools.append(x_web_search(**kwargs))
+            except Exception:
+                tools.append(x_web_search())
+
+        # X SEARCH
+        if is_x_enabled and x_x_search is not None:
+            kwargs: Dict[str, Any] = {}
+            '''
+            inc = self._as_list(cfg.get("remote_tools.xai.x.included_handles"), 10)
+            exc = self._as_list(cfg.get("remote_tools.xai.x.excluded_handles"), 10)
+            if inc and not exc:
+                kwargs["allowed_x_handles"] = inc
+            elif exc and not inc:
+                kwargs["excluded_x_handles"] = exc
+            '''
+            # optional date range filters (YYYY-MM-DD)
+            for k_in, k_out in (("remote_tools.xai.from_date", "from_date"),
+                                ("remote_tools.xai.to_date", "to_date")):
+                v = cfg.get(k_in)
+                if isinstance(v, str) and v.strip():
+                    kwargs[k_out] = v.strip()
+
+            if bool(cfg.get("remote_tools.xai.x.enable_image_understanding", False)):
+                kwargs["enable_image_understanding"] = True
+            if bool(cfg.get("remote_tools.xai.x.enable_video_understanding", False)):
+                kwargs["enable_video_understanding"] = True
+
+            # optional favorites/views filters (supported by live search)
+            try:
+                favs = cfg.get("remote_tools.xai.x.min_favs")
+                if isinstance(favs, int) and favs > 0:
+                    kwargs["post_favorite_count"] = int(favs)
+            except Exception:
+                pass
+            try:
+                views = cfg.get("remote_tools.xai.x.min_views")
+                if isinstance(views, int) and views > 0:
+                    kwargs["post_view_count"] = int(views)
+            except Exception:
+                pass
+
+            try:
+                tools.append(x_x_search(**kwargs))
+            except Exception:
+                tools.append(x_x_search())
+
+        # CODE EXECUTION
+        if is_code_enabled and x_code_execution is not None:
+            try:
+                tools.append(x_code_execution())
+            except Exception:
+                pass
+
+        # MCP
+        if is_mcp_enabled and x_mcp is not None:
+            kwargs = {}
+            mcp_config = cfg.get("remote_tools.xai.mcp.args", "")
+            if mcp_config:
+                try:
+                    kwargs = json.loads(mcp_config)
+                except Exception:
+                    pass
+                try:
+                    tools.append(x_mcp(**kwargs))
+                except Exception:
+                    pass
+
+        # COLLECTIONS SEARCH
+        is_collections_enabled = bool(cfg.get("remote_tools.xai.collections", False))
+        ids = cfg.get("remote_tools.xai.collections.args", "")
+        ids_list = []
+        if ids:
+            try:
+                ids_list = [s.strip() for s in ids.split(",") if s.strip()]
+            except Exception:
+                pass
+        if is_collections_enabled and ids_list:
+            try:
+                tools.append(x_collections_search(
+                    collection_ids=ids_list
+                ))
+            except Exception:
+                pass
+
+        return {
+            "tools": tools,
+            "include": include,
+            "use_encrypted_content": use_encrypted,
+            "max_turns": max_turns,
+        }
+
     def build_remote_tools(self, model: ModelItem = None) -> Dict[str, Any]:
         """
         Return live-search config for xAI:
@@ -58,38 +225,17 @@ class Remote:
         """
         cfg = self.window.core.config
         is_web = self.window.controller.chat.remote_tools.enabled(model, "web_search")  # get global config
-
-        mode = str(cfg.get("remote_tools.xai.mode") or "auto").lower()
-        if mode not in ("auto", "on", "off"):
-            mode = "auto"
-
-        if mode == "off":
-            if is_web:
-                mode = "on"  # override off if global web_search enabled
+        mode = "on" if is_web else "off"
 
         # sources toggles
-        s_web = bool(cfg.get("remote_tools.xai.sources.web", True))
-        s_x   = bool(cfg.get("remote_tools.xai.sources.x", True))
-        s_news = bool(cfg.get("remote_tools.xai.sources.news", False))
-        s_rss  = bool(cfg.get("remote_tools.xai.sources.rss", False))
-
-        # advanced flags
-        adv_web_allowed   = self._has_list(cfg.get("remote_tools.xai.web.allowed_websites"))
-        adv_web_excluded  = self._has_list(cfg.get("remote_tools.xai.web.excluded_websites"))
-        adv_web_country   = self._has_str(cfg.get("remote_tools.xai.web.country"))
-        adv_web_safe      = cfg.get("remote_tools.xai.web.safe_search", None)
-
-        adv_news_excl     = self._has_list(cfg.get("remote_tools.xai.news.excluded_websites"))
-        adv_news_country  = self._has_str(cfg.get("remote_tools.xai.news.country"))
-        adv_news_safe     = cfg.get("remote_tools.xai.news.safe_search", None)
+        s_web =  bool(cfg.get("remote_tools.xai.web_search", False))
+        s_x   =  bool(cfg.get("remote_tools.xai.x_search", False))
 
         adv_x_incl        = self._has_list(cfg.get("remote_tools.xai.x.included_handles"))
         adv_x_excl        = self._has_list(cfg.get("remote_tools.xai.x.excluded_handles"))
         adv_x_favs        = self._has_int(cfg.get("remote_tools.xai.x.min_favs"))
         adv_x_views       = self._has_int(cfg.get("remote_tools.xai.x.min_views"))
 
-        adv_rss_link      = self._has_str(cfg.get("remote_tools.xai.rss.link"))
-
         adv_from          = self._has_str(cfg.get("remote_tools.xai.from_date"))
         adv_to            = self._has_str(cfg.get("remote_tools.xai.to_date"))
 
@@ -97,7 +243,7 @@ class Remote:
         adv_return_cits   = cfg.get("remote_tools.xai.return_citations", True) is not True  # different than default?
 
         # SDK-capable if: mode!=off and ONLY X is enabled and no X filters/date/max_results customizations
-        x_only = s_x and not s_web and not s_news and not s_rss
+        x_only = s_x and not s_web
         x_filters = any([adv_x_incl, adv_x_excl, adv_x_favs, adv_x_views])
         sdk_enabled = (mode != "off") and x_only and not any([
             x_filters, adv_from, adv_to, adv_max_results, adv_return_cits
@@ -110,10 +256,10 @@ class Remote:
 
         need_http = (mode != "off") and (
             not sdk_enabled or                # advanced X filters or other sources/date/results/citations
-            s_web or s_news or s_rss
+            s_web
         )
         if need_http:
-            http_params = self._build_http_params(cfg, mode, s_web, s_x, s_news, s_rss)
+            http_params = self._build_http_params(cfg, mode, s_web, s_x)
             http_reason = "advanced_sources_or_filters"
 
         return {
@@ -131,8 +277,6 @@ class Remote:
             mode: str,
             s_web: bool,
             s_x: bool,
-            s_news: bool,
-            s_rss: bool
     ) -> dict:
         """
         Build search_parameters for Chat Completions (HTTP).
@@ -141,8 +285,6 @@ class Remote:
         :param mode: "auto"|"on"|"off"
         :param s_web: Include web search
         :param s_x: Include X search
-        :param s_news: Include news search
-        :param s_rss: Include RSS search
         :return: search_parameters dict
         """
         params: Dict[str, Any] = {"mode": mode}
@@ -196,41 +338,12 @@ class Remote:
                 xsrc["post_view_count"] = int(views)
             sources.append(xsrc)
 
-        if s_news:
-            news: Dict[str, Any] = {"type": "news"}
-            country = cfg.get("remote_tools.xai.news.country")
-            if isinstance(country, str) and len(country.strip()) == 2:
-                news["country"] = country.strip().upper()
-            excluded = self._as_list(cfg.get("remote_tools.xai.news.excluded_websites"), 5)
-            if excluded:
-                news["excluded_websites"] = excluded
-            safe = cfg.get("remote_tools.xai.news.safe_search")
-            if safe is not None:
-                news["safe_search"] = bool(safe)
-            sources.append(news)
-
-        if s_rss:
-            link = cfg.get("remote_tools.xai.rss.link")
-            if isinstance(link, str) and link.strip():
-                sources.append({"type": "rss", "links": [link.strip()]})
-
         if sources:
             params["sources"] = sources
 
         return params
 
-    def _has_list(self, v) -> bool:
-        """
-        Return True if v is a non-empty list/tuple or a non-empty comma-separated string.
-
-        :param v: Any
-        :return: bool
-        """
-        if v is None:
-            return False
-        if isinstance(v, (list, tuple)):
-            return len([x for x in v if str(x).strip()]) > 0
-        return len([x for x in str(v).split(",") if x.strip()]) > 0
+    # ---------- helpers ----------
 
     def _has_str(self, v) -> bool:
         """
@@ -250,14 +363,14 @@ class Remote:
         """
         return isinstance(v, int) and v > 0
 
-    def _as_list(self, v, limit: int) -> List[str]:
-        """
-        Convert v to a list of strings, limited to 'limit' items.
+    def _has_list(self, v) -> bool:
+        if v is None:
+            return False
+        if isinstance(v, (list, tuple)):
+            return len([x for x in v if str(x).strip()]) > 0
+        return len([x for x in str(v).split(",") if x.strip()]) > 0
 
-        :param v: Any
-        :param limit: limit number of items
-        :return: List of strings
-        """
+    def _as_list(self, v, limit: int) -> List[str]:
         if v is None:
             return []
         if isinstance(v, (list, tuple)):