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

pygpt_net/provider/api/x_ai/__init__.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.03 17:00:00                  #
+# Updated Date: 2026.01.06 20:00:00                  #
 # ================================================== #
 
 from typing import Optional, Dict, Any
@@ -33,7 +33,10 @@ from .vision import Vision
 from .tools import Tools
 from .audio import Audio
 from .image import Image
-from .remote import Remote
+from .remote_tools import Remote
+from .responses import Responses
+from .store import Store
+from .realtime import Realtime
 
 
 class ApiXAI:
@@ -49,7 +52,10 @@ class ApiXAI:
         self.tools = Tools(window)
         self.audio = Audio(window)
         self.image = Image(window)
-        self.remote = Remote(window)  # Live Search builder
+        self.remote = Remote(window)
+        self.responses = Responses(window)
+        self.store = Store(window)
+        self.realtime = Realtime(window)
         self.client: Optional[xai_sdk.Client] = None
         self.locked = False
         self.last_client_args: Optional[Dict[str, Any]] = None
@@ -57,7 +63,8 @@ class ApiXAI:
     def get_client(
             self,
             mode: str = MODE_CHAT,
-            model: ModelItem = None
+            model: ModelItem = None,
+            management_api_key = None
     ) -> xai_sdk.Client:
         """
         Get or create xAI client.
@@ -67,11 +74,9 @@ class ApiXAI:
 
         :param mode: One of MODE_*
         :param model: ModelItem (optional, not used currently)
+        :param management_api_key: Override API key (for management calls)
         :return: xai_sdk.Client
         """
-        if self.client is not None:
-            return self.client
-
         cfg = self.window.core.config
         api_key = cfg.get("api_key_xai") or os.environ.get("XAI_API_KEY") or ""
         timeout = cfg.get("api_native_xai.timeout")  # optional
@@ -88,7 +93,13 @@ class ApiXAI:
         if proxy:
             kwargs["channel_options"] = []
             kwargs["channel_options"].append(("grpc.http_proxy", proxy))
+        if management_api_key:
+            kwargs["management_api_key"] = management_api_key
+
+        if self.client is not None and self.last_client_args == kwargs:
+            return self.client
 
+        self.last_client_args = kwargs
         self.client = xai_sdk.Client(**kwargs)
         return self.client
 
@@ -101,8 +112,9 @@ class ApiXAI:
         """
         Make an API call to xAI.
 
-        Supports chat (stream/non-stream), images (via REST),
-        and function-calling. Audio is not available in public xAI SDK at this time.
+        Uses old API and Chat Responses (stateful) via xai_sdk:
+        - Streaming: chat.stream() (tuples of (response, chunk))
+        - Non-stream: chat.sample()
 
         :param context: BridgeContext
         :param extra: Extra params (not used)
@@ -113,19 +125,45 @@ class ApiXAI:
         stream = context.stream
         ctx = context.ctx
         ai_name = (ctx.output_name if ctx else "assistant")
+        model = context.model  # model instance (item, not id)
         used_tokens = 0
         response = None
         ctx.chunk_type = ChunkType.XAI_SDK
+        
+        use_responses_api = True
+        if model and model.id.startswith("grok-3"):
+            use_responses_api = False  # use old API
 
         if mode in (
                 MODE_COMPLETION,
                 MODE_CHAT,
                 MODE_AUDIO,
-                MODE_RESEARCH
+                MODE_RESEARCH,
+                MODE_AUDIO
         ):
-            # There is no public realtime audio in SDK; treat MODE_AUDIO as chat (TTS not supported).
-            response = self.chat.send(context=context, extra=extra)
-            used_tokens = self.chat.get_used_tokens()
+            if mode == MODE_AUDIO:
+                raise NotImplementedError("Not available. xAI realtime audio streaming coming soon!")
+
+            if mode == MODE_AUDIO and stream:
+                # Realtime API for audio streaming
+                is_realtime = self.realtime.begin(
+                    context=context,
+                    model=model,
+                    extra=extra or {},
+                    rt_signals=rt_signals
+                )
+                if is_realtime:
+                    return True
+
+            # Audio TTS is not exposed via public SDK; treat MODE_AUDIO as chat input.
+            # NOTE: for grok-3 use Chat completions, for > grok-4 use Chat responses
+            if use_responses_api:
+                response = self.responses.send(context=context, extra=extra)  # responses
+                used_tokens = self.responses.get_used_tokens()
+            else:
+                response = self.chat.send(context=context, extra=extra)  # completions
+                used_tokens = self.chat.get_used_tokens()
+
             if ctx:
                 self.vision.append_images(ctx)
 
@@ -151,7 +189,10 @@ class ApiXAI:
 
         if ctx:
             ctx.ai_name = ai_name
-            self.chat.unpack_response(context.mode, response, ctx)
+            if use_responses_api:
+                self.responses.unpack_response(context.mode, response, ctx)
+            else:
+                self.chat.unpack_response(context.mode, response, ctx)
             try:
                 for tc in getattr(ctx, "tool_calls", []) or []:
                     fn = tc.get("function") or {}
@@ -175,6 +216,88 @@ class ApiXAI:
 
         If context.request is set, makes a full call() instead (for consistency).
 
+        :param context: BridgeContext
+        :param extra: Extra params (not used)
+        :return: Output text or "" on error
+        """
+        model = context.model or self.window.core.models.from_defaults()
+        if model and model.id.startswith("grok-3"):
+            return self.quick_call_old(context, extra)  # grok-3 uses old path
+
+        if context.request:
+            context.stream = False
+            context.mode = MODE_CHAT
+            self.locked = True
+            self.call(context, extra)
+            self.locked = False
+            return context.ctx.output
+
+        self.locked = True
+        try:
+            ctx = context.ctx
+            prompt = context.prompt
+            system_prompt = context.system_prompt
+            history = context.history
+            functions = context.external_functions
+            attachments = context.attachments
+            multimodal_ctx = context.multimodal_ctx
+
+            # Prepare client-side tools for SDK (no server-side tools in quick_call)
+            client_tools = self.tools.prepare_sdk_tools(functions)
+
+            client = self.get_client(MODE_CHAT, model)
+            # store_messages: false for quick, and false if images present (SDK guidance)
+            store_messages = False
+            prev_id = None
+
+            # Create chat session
+            include = []
+            chat = client.chat.create(
+                model=model.id,
+                tools=(client_tools if client_tools else None),
+                include=(include if include else None),
+                store_messages=store_messages,
+                previous_response_id=prev_id,
+            )
+
+            # Append history if enabled and no previous_response_id is used
+            self.responses.append_history_sdk(
+                chat=chat,
+                system_prompt=system_prompt,
+                model=model,
+                history=history,
+            )
+
+            # Append current prompt with optional images
+            self.responses.append_current_user_sdk(
+                chat=chat,
+                prompt=prompt,
+                attachments=attachments,
+                multimodal_ctx=multimodal_ctx,
+            )
+
+            resp = chat.sample()
+            # Extract client-side tool calls if any (leave server-side out)
+            out = getattr(resp, "content", "") or ""
+            if ctx:
+                self.responses.quick_collect_response_id(resp, ctx)
+            return out.strip()
+        except Exception as e:
+            self.window.core.debug.log(e)
+            return ""
+        finally:
+            self.locked = False
+
+    def quick_call_old(
+            self,
+            context: BridgeContext,
+            extra: dict = None
+    ) -> str:
+        """
+        Quick non-streaming xAI chat call and return output text.
+
+        If context.request is set, makes a full call() instead (for consistency).
+
         :param context: BridgeContext
         :param extra: Extra params (not used)
         :return: Output text or "" on error
@@ -202,7 +325,7 @@ class ApiXAI:
             # If tools are present, prefer non-streaming HTTP Chat Completions path to extract tool calls reliably.
             # Otherwise use native SDK chat.sample().
             if tools:
-                out, calls, citations, usage  = self.chat.call_http_nonstream(
+                out, calls, citations, usage = self.chat.call_http_nonstream(
                     model=model.id,
                     prompt=prompt,
                     system_prompt=system_prompt,

pygpt_net/provider/api/x_ai/audio.py

@@ -6,27 +6,59 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 01:00:00                  #
+# Updated Date: 2026.01.06 20:00:00                  #
 # ================================================== #
 
-from typing import Tuple
+import base64
+from typing import Optional, Union, List, Dict, Any
+
+from pygpt_net.core.bridge.context import MultimodalContext
 
 
 class Audio:
     def __init__(self, window=None):
         """
-        Audio helpers for xAI.
-
-        Note: As of now, the public xAI Python SDK does not expose TTS/STT or realtime audio APIs.
-        This class exists to keep provider surface compatible.
+        Audio input wrapper
 
         :param window: Window instance
         """
         self.window = window
 
-    # Placeholders to keep interface parity
-    def build_part(self, multimodal_ctx) -> None:
-        return None
+    def build_content(
+            self,
+            content: Optional[Union[str, list]] = None,
+            multimodal_ctx: Optional[MultimodalContext] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Build audio content from multimodal context
+
+        :param content: previous content or input prompt
+        :param multimodal_ctx: multimodal context
+        :return: List of contents
+        """
+        if not isinstance(content, list):
+            if content:
+                content = [
+                    {
+                        "type": "text",
+                        "text": str(content),
+                    }
+                ]
+            else:
+                content = []  # if empty input return empty list
+
+        # abort if no audio input provided
+        if not multimodal_ctx.is_audio_input:
+            return content
 
-    def extract_first_audio_part(self, response) -> Tuple[None, None]:
-        return None, None
+        encoded = base64.b64encode(multimodal_ctx.audio_data).decode('utf-8')
+        audio_format = multimodal_ctx.audio_format  # wav by default
+        audio_data = {
+            "type": "input_audio",
+            "input_audio": {
+                "data": encoded,
+                "format": audio_format,
+            }
+        }
+        content.append(audio_data)
+        return content

pygpt_net/provider/api/x_ai/chat.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.03 17:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -34,7 +34,6 @@ class Chat:
         """
         self.window = window
         self.input_tokens = 0
-        # Image constraints (can be overridden by config keys below)
         self.allowed_mimes = {"image/jpeg", "image/png"}
         self.default_image_max_bytes = 10 * 1024 * 1024  # 10 MiB default
 
@@ -319,6 +318,12 @@ class Chat:
         except Exception:
             pass
 
+        try:
+            # Attempt to auto-download file parts or references (file id)
+            self._maybe_download_files_from_response(response, ctx)
+        except Exception:
+            pass
+
         # Usage
         try:
             if isinstance(response, dict) and response.get("usage"):
@@ -1089,7 +1094,7 @@ class Chat:
 
     def _collect_images_from_message_parts(self, parts: List[dict], ctx: CtxItem):
         """
-        Inspect assistant message parts for image_url outputs and store them.
+        Inspect assistant message parts for image_url outputs and URLs.
         For http(s) URLs -> add to ctx.urls; for data URLs -> save to file and add to ctx.images.
         """
         try:
@@ -1098,6 +1103,25 @@ class Chat:
             for p in parts:
                 if not isinstance(p, dict):
                     continue
+                if p.get("type") == "file":
+                    file_id = p.get("id") or p.get("file_id")
+                    if isinstance(file_id, str):
+                        try:
+                            save = self.window.core.api.xai.store.download_to_dir(file_id)
+                            if save:
+                                if not isinstance(ctx.files, list):
+                                    ctx.files = []
+                                if save not in ctx.files:
+                                    ctx.files.append(save)
+                                ext = os.path.splitext(save)[1].lower().lstrip(".")
+                                if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                                    if not isinstance(ctx.images, list):
+                                        ctx.images = []
+                                    if save not in ctx.images:
+                                        ctx.images.append(save)
+                        except Exception:
+                            pass
+                    continue
                 if p.get("type") != "image_url":
                     continue
                 img = p.get("image_url") or {}
@@ -1135,4 +1159,68 @@ class Chat:
         """
         Return the locally estimated input tokens count.
         """
-        return self.input_tokens
+        return self.input_tokens
+
+    def _maybe_download_files_from_response(self, response, ctx: CtxItem) -> None:
+        """
+        Attempt to download any files referenced by id in response payloads (dict/SDK/proto).
+        """
+        def _walk(o, acc: set):
+            if o is None:
+                return
+            if isinstance(o, dict):
+                fid = o.get("file_id") or o.get("id") if o.get("type") == "file" else None
+                if isinstance(fid, str) and fid.startswith("file-"):
+                    acc.add(fid)
+                for v in o.values():
+                    _walk(v, acc)
+            elif isinstance(o, (list, tuple)):
+                for it in o:
+                    _walk(it, acc)
+
+        ids = set()
+        try:
+            if isinstance(response, dict):
+                _walk(response, ids)
+            else:
+                msg = getattr(response, "message", None) or getattr(response, "output_message", None)
+                if msg:
+                    _walk(getattr(msg, "content", None), ids)
+                proto = getattr(response, "proto", None)
+                if proto:
+                    ch = getattr(proto, "choices", None) or []
+                    if ch:
+                        m = getattr(ch[0], "message", None)
+                        if m:
+                            _walk(getattr(m, "content", None), ids)
+        except Exception:
+            pass
+
+        if not ids:
+            return
+        saved = []
+        for fid in ids:
+            try:
+                p = self.window.core.api.xai.store.download_to_dir(fid)
+                if p:
+                    saved.append(p)
+            except Exception:
+                continue
+        if saved:
+            saved = self.window.core.filesystem.make_local_list(saved)
+            if not isinstance(ctx.files, list):
+                ctx.files = []
+            for p in saved:
+                if p not in ctx.files:
+                    ctx.files.append(p)
+            imgs = []
+            for p in saved:
+                ext = os.path.splitext(p)[1].lower().lstrip(".")
+                if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                    imgs.append(p)
+            if imgs:
+                if not isinstance(ctx.images, list):
+                    ctx.images = []
+                for p in imgs:
+                    if p not in ctx.images:
+                        ctx.images.append(p)