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

pygpt_net/{controller/chat/handler/xai_stream.py → provider/api/x_ai/stream.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 typing import Optional, List, Dict, Any
@@ -69,10 +69,8 @@ def _extract_http_urls_from_text(text: Optional[str]) -> List[str]:
     """
     if not text or not isinstance(text, str):
         return []
-    # Basic, conservative URL regex
     pattern = re.compile(r"(https?://[^\s)>\]\"']+)", re.IGNORECASE)
     urls = pattern.findall(text)
-    # Deduplicate while preserving order
     out, seen = [], set()
     for u in urls:
         if u not in seen:
@@ -134,6 +132,7 @@ def _process_message_content_for_outputs(core, ctx, state, content):
     - If image_url.url is data:... -> save to file and append to state.image_paths + ctx.images
     - If image_url.url is http(s) -> append to ctx.urls
     - Extract URLs from adjacent text parts conservatively
+    - If file part present -> auto-download via Files API
     """
     if not isinstance(content, list):
         return
@@ -162,7 +161,28 @@ def _process_message_content_for_outputs(core, ctx, state, content):
                 urls = _extract_http_urls_from_text(t)
                 if urls:
                     _append_urls(ctx, state, urls)
-    # If images were added, mark flag similarly to Google path
+        elif ptype == "file":
+            fid = p.get("id") or p.get("file_id")
+            if isinstance(fid, str):
+                if not hasattr(state, "xai_downloaded_file_ids"):
+                    state.xai_downloaded_file_ids = set()
+                if fid not in state.xai_downloaded_file_ids:
+                    try:
+                        path = core.api.xai.store.download_to_dir(fid)
+                    except Exception:
+                        path = None
+                    if path:
+                        if not isinstance(ctx.files, list):
+                            ctx.files = []
+                        if path not in ctx.files:
+                            ctx.files.append(path)
+                        ext = path.lower().rsplit(".", 1)[-1] if "." in path else ""
+                        if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                            if not isinstance(ctx.images, list):
+                                ctx.images = []
+                            if path not in ctx.images:
+                                ctx.images.append(path)
+                        state.xai_downloaded_file_ids.add(fid)
     if any_image:
         try:
             state.has_xai_inline_image = True
@@ -296,9 +316,20 @@ def process_xai_sdk_chunk(ctx, core, state, item) -> Optional[str]:
     except Exception:
         return None
 
+    # persist last response and attach response id to ctx once
     try:
         if response is not None:
             state.xai_last_response = response
+            rid = getattr(response, "id", None)
+            if rid and not getattr(ctx, "msg_id", None):
+                ctx.msg_id = str(rid)
+                if not isinstance(ctx.extra, dict):
+                    ctx.extra = {}
+                ctx.extra["xai_response_id"] = ctx.msg_id
+                try:
+                    core.ctx.update_item(ctx)
+                except Exception:
+                    pass
     except Exception:
         pass
 
@@ -353,7 +384,6 @@ def process_xai_sdk_chunk(ctx, core, state, item) -> Optional[str]:
         if hasattr(chunk, "content"):
             t = _stringify_content(getattr(chunk, "content"))
             if t:
-                # collect URLs from text content conservatively
                 _append_urls(ctx, state, _extract_http_urls_from_text(t))
                 return str(t)
     except Exception:
@@ -414,11 +444,8 @@ def process_xai_sdk_chunk(ctx, core, state, item) -> Optional[str]:
                 if "content" in m and m["content"] is not None:
                     mc = m["content"]
                     # inspect for image_url outputs and URLs
-                    _process_message_content_for_outputs(core, ctx, state, mc if isinstance(mc, list) else [])
-                    if isinstance(mc, str):
-                        _append_urls(ctx, state, _extract_http_urls_from_text(mc))
-                        return mc
-                    elif isinstance(mc, list):
+                    if isinstance(mc, list):
+                        _process_message_content_for_outputs(core, ctx, state, mc)
                         out_parts: List[str] = []
                         for p in mc:
                             if isinstance(p, dict) and p.get("type") == "text":
@@ -429,6 +456,11 @@ def process_xai_sdk_chunk(ctx, core, state, item) -> Optional[str]:
                             txt = "".join(out_parts)
                             _append_urls(ctx, state, _extract_http_urls_from_text(txt))
                             return txt
+                    else:
+                        t = _stringify_content(mc)
+                        if t:
+                            _append_urls(ctx, state, _extract_http_urls_from_text(t))
+                            return str(t)
 
             # root-level delta/message
             if isinstance(chunk.get("delta"), dict) and "content" in chunk["delta"]:

pygpt_net/provider/api/x_ai/tools.py

@@ -6,20 +6,26 @@
 # 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.04 19:00:00                  #
 # ================================================== #
 
 import json
 from typing import List, Any, Optional
 
+# xAI SDK client-side tool descriptor
+try:
+    from xai_sdk.chat import tool as x_tool
+except Exception:
+    x_tool = None
+
 
 class Tools:
     def __init__(self, window=None):
         """
-        Tools mapper for xAI Chat Completions-compatible schema.
+        Tools mapper for xAI.
 
-        Input: app 'functions' list with keys: name, desc, params (JSON Schema string).
-        Output: list of dicts with keys: name, description, parameters.
+        - prepare(): legacy OpenAI-compatible dicts (kept for compatibility if needed).
+        - prepare_sdk_tools(): xAI SDK client-side tool descriptors for Chat Responses.
 
         :param window: Window instance
         """
@@ -84,12 +90,10 @@ class Tools:
 
     def prepare(self, functions: list) -> List[dict]:
         """
-        Prepare xAI tools list (OpenAI-compatible schema) from app functions list.
-
-        Returns [] if no functions provided.
+        Prepare legacy xAI/OpenAI-compatible tools list from app functions list.
 
         :param functions: List of functions with keys: name (str), desc (str), params (JSON Schema str)
-        :return: List of tools with keys: name (str), description (str), parameters (dict)
+        :return: List of tools in dict format
         """
         if not functions or not isinstance(functions, list):
             return []
@@ -117,4 +121,51 @@ class Tools:
                 "description": desc,
                 "parameters": params,
             })
+        return tools
+
+    def prepare_sdk_tools(self, functions: list) -> List[object]:
+        """
+        Prepare xAI SDK client-side tool descriptors for Chat Responses.
+
+        :param functions: List of functions with keys: name (str), desc (str), params (JSON Schema str)
+        :return: List of xai_sdk.chat.tool(...) objects
+        """
+        if x_tool is None:
+            return []  # SDK too old; skip silently
+        if not functions or not isinstance(functions, list):
+            return []
+
+        tools: List[object] = []
+        for fn in functions:
+            name = str(fn.get("name") or "").strip()
+            if not name:
+                continue
+            desc = fn.get("desc") or ""
+            params: Optional[dict] = {}
+            if fn.get("params"):
+                try:
+                    params = json.loads(fn["params"])
+                except Exception:
+                    params = {}
+                params = self._sanitize_schema(params or {})
+                if not params.get("type"):
+                    params["type"] = "object"
+            else:
+                params = {"type": "object"}
+            try:
+                tools.append(x_tool(
+                    name=name,
+                    description=desc,
+                    parameters=params,
+                ))
+            except Exception:
+                # In case of schema issues, fallback to empty-params tool
+                try:
+                    tools.append(x_tool(
+                        name=name,
+                        description=desc,
+                        parameters={"type": "object"},
+                    ))
+                except Exception:
+                    continue
         return tools

pygpt_net/{controller/chat/handler → provider/api/x_ai}/utils.py

@@ -6,10 +6,9 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 00:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
-import base64
 from typing import Any, Optional
 
 

pygpt_net/provider/api/x_ai/vision.py

@@ -6,7 +6,7 @@
 # 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.04 19:00:00                  #
 # ================================================== #
 
 import os
@@ -50,9 +50,6 @@ class Vision:
             try:
                 if att.path and self.window.core.api.xai.vision.is_image(att.path):
                     mime = self.window.core.api.xai.vision.guess_mime(att.path)
-                    # Accept only JPEG/PNG for SDK too (for consistency)
-                    #if mime not in self.allowed_mimes:
-                       # continue
                     with open(att.path, "rb") as f:
                         b64 = base64.b64encode(f.read()).decode("utf-8")
                     images.append(f"data:{mime};base64,{b64}")

pygpt_net/provider/api/x_ai/worker/importer.py

@@ -0,0 +1,308 @@
+#!/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 06:00:00                  #
+# ================================================== #
+
+import os
+
+from PySide6.QtCore import QObject, Signal, QRunnable, Slot
+
+
+class Importer(QObject):
+    def __init__(self, window=None):
+        """
+        Importer core (xAI Collections)
+
+        :param window: Window instance
+        """
+        super(Importer, self).__init__()
+        self.window = window
+        self.worker = None
+
+    @Slot(str, object)
+    def handle_error(self, mode: str, err: any):
+        batch = self.window.controller.remote_store.batch
+        if mode == "import_files":
+            batch.handle_imported_files_failed(err)
+        elif mode == "truncate_files":
+            batch.handle_truncated_files_failed(err)
+        elif mode == "upload_files":
+            batch.handle_uploaded_files_failed(err)
+        elif mode in "vector_stores":
+            batch.handle_imported_stores_failed(err)
+        elif mode in "truncate_vector_stores":
+            batch.handle_truncated_stores_failed(err)
+        elif mode in "refresh_vector_stores":
+            batch.handle_refreshed_stores_failed(err)
+
+    @Slot(str, str, int)
+    def handle_finished(self, mode: str, store_id: str = None, num: int = 0):
+        batch = self.window.controller.remote_store.batch
+        if mode == "import_files":
+            batch.handle_imported_files(num)
+        elif mode == "truncate_files":
+            batch.handle_truncated_files(store_id, num)
+        elif mode == "upload_files":
+            batch.handle_uploaded_files(num)
+        elif mode == "vector_stores":
+            batch.handle_imported_stores(num)
+        elif mode == "truncate_vector_stores":
+            batch.handle_truncated_stores(num)
+        elif mode == "refresh_vector_stores":
+            batch.handle_refreshed_stores(num)
+
+    @Slot(str, str)
+    def handle_status(self, mode: str, msg: str):
+        self.window.controller.assistant.batch.handle_status_change(mode, msg)
+
+    @Slot(str, str)
+    def handle_log(self, mode: str, msg: str):
+        self.window.controller.assistant.threads.log(mode + ": " + msg)
+
+    # ---------- Vector stores (Collections) ----------
+
+    def import_vector_stores(self):
+        """Import collections"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def truncate_vector_stores(self):
+        """Delete collections"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "truncate_vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def refresh_vector_stores(self):
+        """Refresh collections"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "refresh_vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    # ---------- Files (documents) ----------
+
+    def truncate_files(self, store_id: str = None):
+        """Remove documents from one/all collections"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "truncate_files"
+        self.worker.store_id = store_id
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def upload_files(self, store_id: str, files: list = None):
+        """Upload files to a collection"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "upload_files"
+        self.worker.store_id = store_id
+        self.worker.files = files or []
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def import_files(self, store_id: str = None):
+        """Import documents from one/all collections"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "import_files"
+        self.worker.store_id = store_id
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def connect_signals(self, worker):
+        worker.signals.finished.connect(self.handle_finished)
+        worker.signals.error.connect(self.handle_error)
+        worker.signals.status.connect(self.handle_status)
+        worker.signals.log.connect(self.handle_log)
+
+
+class ImportWorkerSignals(QObject):
+    status = Signal(str, str)            # mode, message
+    finished = Signal(str, str, int)     # mode, store_id, num
+    error = Signal(str, object)          # mode, error
+    log = Signal(str, str)               # mode, message
+
+
+class ImportWorker(QRunnable):
+    """Import worker (xAI Collections)"""
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.signals = ImportWorkerSignals()
+        self.window = None
+        self.mode = "vector_stores"
+        self.store_id = None
+        self.files = []
+
+    @Slot()
+    def run(self):
+        try:
+            if self.mode == "vector_stores":
+                if self.import_vector_stores():
+                    self.import_files()
+            elif self.mode == "truncate_vector_stores":
+                self.truncate_vector_stores()
+            elif self.mode == "refresh_vector_stores":
+                self.refresh_vector_stores()
+            elif self.mode == "truncate_files":
+                self.truncate_files()
+            elif self.mode == "import_files":
+                self.import_files()
+            elif self.mode == "upload_files":
+                self.upload_files()
+        except Exception as e:
+            self.signals.error.emit(self.mode, e)
+        finally:
+            self.cleanup()
+
+    # ---------- Collections ----------
+
+    def import_vector_stores(self, silent: bool = False) -> bool:
+        try:
+            self.log("Importing collections...")
+            self.window.core.remote_store.xai.clear()
+            items = {}
+            self.window.core.api.xai.store.import_collections_collections(items, callback=self.callback)
+            self.window.core.remote_store.xai.import_items(items)
+            if not silent:
+                self.signals.finished.emit("vector_stores", self.store_id, len(items))
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("vector_stores", e)
+            return False
+
+    def truncate_vector_stores(self, silent: bool = False) -> bool:
+        try:
+            self.log("Truncating collections...")
+            num = self.window.core.api.xai.store.remove_all_collections_collections(callback=self.callback)
+            self.window.core.remote_store.xai.items = {}
+            self.window.core.remote_store.xai.save()
+            if not silent:
+                self.signals.finished.emit("truncate_vector_stores", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("truncate_vector_stores", e)
+            return False
+
+    def refresh_vector_stores(self, silent: bool = False) -> bool:
+        try:
+            self.log("Refreshing collections...")
+            num = 0
+            stores = self.window.core.remote_store.xai.items
+            for id in list(stores.keys()):
+                store = stores[id]
+                try:
+                    self.window.controller.remote_store.refresh_store(store, update=False, provider="xai")
+                    num += 1
+                except Exception as e:
+                    self.log("Failed to refresh collection: {}".format(id))
+                    self.window.core.debug.log(e)
+            if not silent:
+                self.signals.finished.emit("refresh_vector_stores", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("refresh_vector_stores", e)
+            return False
+
+    # ---------- Documents ----------
+
+    def truncate_files(self, silent: bool = False) -> bool:
+        try:
+            if self.store_id is None:
+                self.log("Truncating all collection documents...")
+                self.window.core.remote_store.xai.files.truncate()  # clear all local + detach from all collections
+                num = self.window.core.api.xai.store.remove_files(callback=self.callback)  # delete remote files
+            else:
+                self.log("Truncating documents for collection: {}".format(self.store_id))
+                self.window.core.remote_store.xai.files.truncate(self.store_id)  # clear local + detach from this collection
+                num = self.window.core.api.xai.store.remove_from_collection_collections(
+                    self.store_id,
+                    callback=self.callback,
+                )
+            if not silent:
+                self.signals.finished.emit("truncate_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("truncate_files", e)
+            return False
+
+    def upload_files(self, silent: bool = False) -> bool:
+        num = 0
+        try:
+            self.log("Uploading files to collection...")
+            for path in self.files:
+                try:
+                    doc = self.window.core.api.xai.store.upload_to_collection_collections(self.store_id, path)
+                    if doc is not None:
+                        self.window.core.remote_store.xai.files.insert(self.store_id, doc.file_metadata)
+                        num += 1
+                        msg = "Uploaded file: {}/{}".format(num, len(self.files))
+                        self.signals.status.emit("upload_files", msg)
+                        self.log(msg)
+                    else:
+                        self.signals.status.emit("upload_files", "Failed to upload: {}".format(os.path.basename(path)))
+                except Exception as e:
+                    self.window.core.debug.log(e)
+                    self.signals.status.emit("upload_files", "Failed to upload: {}".format(os.path.basename(path)))
+            if not silent:
+                self.signals.finished.emit("upload_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("upload_files", e)
+            return False
+
+    def import_files(self, silent: bool = False) -> bool:
+        try:
+            if self.store_id is None:
+                self.log("Importing all collection documents...")
+                self.window.core.remote_store.xai.files.truncate_local()  # clear local DB (all)
+                num = self.window.core.api.xai.store.import_collections_files_collections(callback=self.callback)
+            else:
+                self.log("Importing documents for collection: {}".format(self.store_id))
+                self.window.core.remote_store.xai.files.truncate_local(self.store_id)  # clear local DB (store)
+                items = self.window.core.api.xai.store.import_collection_files_collections(
+                    self.store_id,
+                    [],
+                    callback=self.callback,
+                )
+                num = len(items)
+            if not silent:
+                self.signals.finished.emit("import_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("import_files", e)
+            return False
+
+    # ---------- Utils ----------
+
+    def callback(self, msg: str):
+        self.log(msg)
+
+    def log(self, msg: str):
+        self.signals.log.emit(self.mode, msg)
+
+    def cleanup(self):
+        sig = self.signals
+        self.signals = None
+        if sig is not None:
+            try:
+                sig.deleteLater()
+            except RuntimeError:
+                pass