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

pygpt_net/provider/api/anthropic/tools.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.17 05:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import json
@@ -152,78 +152,16 @@ class Tools:
                 if not params.get("type"):
                     params["type"] = "object"
 
-            tools.append({
+            # pass through tool as client tool
+            tool_def = {
                 "name": name,
                 "description": desc,
                 "input_schema": params or {"type": "object"},
-            })
-
-        return tools
-
-    def build_remote_tools(self, model: ModelItem = None) -> List[dict]:
-        """
-        Build Anthropic server tools (remote tools) based on config flags.
-        Currently supports: Web Search tool.
-
-        Returns a list of tool dicts to be appended to 'tools' in messages.create.
-
-        :param model: ModelItem
-        :return: List of remote tool dicts
-        """
-        cfg = self.window.core.config
-        tools: List[dict] = []
-
-        # sonnet-3.5 is not supported
-        if model and model.id and model.id.startswith("claude-3-5"):
-            return tools
-
-        is_web = self.window.controller.chat.remote_tools.enabled(model, "web_search")  # get global config
-
-        # Web Search tool
-        if is_web:
-            ttype = cfg.get("remote_tools.anthropic.web_search.type", "web_search_20250305")  # stable as of docs
-            tname = "web_search"
-
-            tool_def: Dict[str, Any] = {
-                "type": ttype,
-                "name": tname,
             }
 
-            # Optional params
-            max_uses = cfg.get("remote_tools.anthropic.web_search.max_uses")
-            if isinstance(max_uses, int) and max_uses > 0:
-                tool_def["max_uses"] = max_uses
-
-            def parse_csv_list(key: str) -> list:
-                raw = cfg.get(key, "")
-                if not raw:
-                    return []
-                if isinstance(raw, list):
-                    return [str(x).strip() for x in raw if str(x).strip()]
-                return [s.strip() for s in str(raw).split(",") if s.strip()]
-
-            allowed = parse_csv_list("remote_tools.anthropic.web_search.allowed_domains")
-            blocked = parse_csv_list("remote_tools.anthropic.web_search.blocked_domains")
-            if allowed:
-                tool_def["allowed_domains"] = allowed
-            elif blocked:
-                tool_def["blocked_domains"] = blocked
-
-            # Location (approximate)
-            loc_city = cfg.get("remote_tools.anthropic.web_search.user_location.city")
-            loc_region = cfg.get("remote_tools.anthropic.web_search.user_location.region")
-            loc_country = cfg.get("remote_tools.anthropic.web_search.user_location.country")
-            loc_tz = cfg.get("remote_tools.anthropic.web_search.user_location.timezone")
-            if any([loc_city, loc_region, loc_country, loc_tz]):
-                tool_def["user_location"] = {
-                    "type": "approximate",
-                    "city": str(loc_city) if loc_city else None,
-                    "region": str(loc_region) if loc_region else None,
-                    "country": str(loc_country) if loc_country else None,
-                    "timezone": str(loc_tz) if loc_tz else None,
-                }
-                # remove None fields
-                tool_def["user_location"] = {k: v for k, v in tool_def["user_location"].items() if v is not None}
+            # optional: allow defer_loading for tool search when configured per-tool (kept compatible)
+            if isinstance(fn, dict) and fn.get("defer_loading") is True:
+                tool_def["defer_loading"] = True
 
             tools.append(tool_def)
 
@@ -231,28 +169,45 @@ class Tools:
 
     def merge_tools_dedup(self, primary: List[dict], secondary: List[dict]) -> List[dict]:
         """
-        Remove duplicate tools by name, preserving order:
+        Remove duplicate tools, preserving order:
 
         - First from primary list
-        - Then from secondary list if name not already present
+        - Then from secondary list if not already present
+
+        Dedup rules:
+          * Tools with a 'name' are deduped by name.
+          * MCP toolsets (type == 'mcp_toolset') are deduped by (type, mcp_server_name).
+          * Tools without a 'name' use (type) as a fallback key.
 
         :param primary: Primary list of tool dicts
         :param secondary: Secondary list of tool dicts
         :return: Merged list of tool dicts without duplicates
         """
+        def key_for(t: dict) -> str:
+            name = t.get("name")
+            if name:
+                return f"name::{name}"
+            ttype = t.get("type")
+            if ttype == "mcp_toolset":
+                return f"mcp::{t.get('mcp_server_name', '')}"
+            return f"type::{ttype}"
+
         result: List[dict] = []
         seen = set()
+
         for t in primary or []:
-            n = t.get("name")
-            if n and n not in seen:
-                seen.add(n)
+            k = key_for(t)
+            if k not in seen:
+                seen.add(k)
                 result.append(t)
+
         for t in secondary or []:
-            n = t.get("name")
-            if not n or n in seen:
+            k = key_for(t)
+            if k in seen:
                 continue
-            seen.add(n)
+            seen.add(k)
             result.append(t)
+
         return result
 
     def get_all_tools(self, model: ModelItem, functions: list) -> List[dict]:
@@ -264,5 +219,5 @@ class Tools:
         :return: Combined list of tool dicts
         """
         base_tools = self.prepare(model, functions)
-        remote_tools = self.build_remote_tools(model)
+        remote_tools = self.window.core.api.anthropic.remote_tools.build_remote_tools(model)
         return self.merge_tools_dedup(base_tools, remote_tools)

pygpt_net/provider/api/anthropic/utils.py

@@ -0,0 +1,30 @@
+#!/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.05 20:00:00                  #
+# ================================================== #
+
+from typing import Any, Optional
+
+
+def as_int(val: Any) -> Optional[int]:
+    """
+    Coerce to int if possible, else None.
+
+    :param val: Input value
+    :return: int or None
+    """
+    if val is None:
+        return None
+    try:
+        return int(val)
+    except Exception:
+        try:
+            return int(float(val))
+        except Exception:
+            return None

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

@@ -0,0 +1,278 @@
+#!/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.05 17:00:00                  #
+# ================================================== #
+
+import os
+
+from PySide6.QtCore import QObject, Signal, QRunnable, Slot
+
+
+class Importer(QObject):
+    def __init__(self, window=None):
+        """
+        Importer core (Anthropic Files)
+
+        :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)
+
+    def import_vector_stores(self):
+        """Create/ensure pseudo-store and import files list."""
+        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):
+        """Clear local pseudo-store metadata (no remote action)."""
+        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 truncate_files(self, store_id: str = None):
+        """Remove all files via Files API."""
+        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 Files API."""
+        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 refresh_vector_stores(self):
+        """Refresh pseudo-store status."""
+        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)
+
+    def import_files(self, store_id: str = None):
+        """Import files from Files API."""
+        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 (Anthropic)"""
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.signals = ImportWorkerSignals()
+        self.window = None
+        self.mode = "vector_stores"
+        self.store_id = "files"
+        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()
+
+    def import_vector_stores(self, silent: bool = False) -> bool:
+        """
+        Ensure pseudo-store exists locally.
+        """
+        try:
+            self.log("Ensuring Anthropic workspace store...")
+            items = {}
+            # Single pseudo-store object
+            store = self.window.core.remote_store.anthropic.create("Files")
+            items[store.id] = store
+            self.window.core.remote_store.anthropic.import_items(items)
+            if not silent:
+                self.signals.finished.emit("vector_stores", self.store_id, 1)
+            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 local pseudo-store...")
+            self.window.core.remote_store.anthropic.items = {}
+            self.window.core.remote_store.anthropic.save()
+            if not silent:
+                self.signals.finished.emit("truncate_vector_stores", self.store_id, 1)
+            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 workspace status...")
+            # Ensure exists
+            if "files" not in self.window.core.remote_store.anthropic.items:
+                self.import_vector_stores(silent=True)
+            store = self.window.core.remote_store.anthropic.items["files"]
+            self.window.controller.remote_store.refresh_store(store, update=False, provider="anthropic")
+            if not silent:
+                self.signals.finished.emit("refresh_vector_stores", self.store_id, 1)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("refresh_vector_stores", e)
+            return False
+
+    def truncate_files(self, silent: bool = False) -> bool:
+        try:
+            self.log("Removing all files via Anthropic Files API...")
+            num = self.window.core.api.anthropic.store.remove_files(callback=self.callback)
+            self.window.core.remote_store.anthropic.files.truncate_local()
+            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 Anthropic Files API...")
+            for path in self.files:
+                try:
+                    f = self.window.core.api.anthropic.store.upload(path)
+                    if f is not None:
+                        self.window.core.remote_store.anthropic.files.insert("files", f)
+                        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:
+            self.log("Importing files from Anthropic Files API...")
+            self.window.core.remote_store.anthropic.files.truncate_local()
+            num = self.window.core.api.anthropic.store.import_files(callback=self.callback)
+            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
+
+    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

pygpt_net/provider/api/google/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                  #
 # ================================================== #
 
 import os
@@ -121,12 +121,8 @@ class Chat:
 
         # Enable Computer Use tool in computer mode (use the official Tool/ComputerUse object)
         if mode == MODE_COMPUTER or (model and isinstance(model.id, str) and "computer-use" in model.id.lower()):
-            comp_env = gtypes.Environment.ENVIRONMENT_BROWSER
-            tools = [gtypes.Tool(
-                computer_use=gtypes.ComputerUse(
-                    environment=comp_env,
-                )
-            )]  # reset tools to only Computer Use (multiple tools not supported together)
+            tool = self.window.core.api.google.computer.get_tool()
+            tools = [tool]  # reset tools to only Computer Use (multiple tools not supported together)
 
         # Some models cannot use tools; keep behavior for image-only models
         if model and isinstance(model.id, str) and "-image" in model.id:
@@ -366,6 +362,12 @@ class Chat:
         except Exception:
             pass
 
+        # Download Files API file_data parts if present
+        try:
+            self._maybe_download_response_files(response, ctx)
+        except Exception:
+            pass
+
     def extract_text(self, response) -> str:
         """
         Extract output text.
@@ -796,7 +798,7 @@ class Chat:
                 return bytes(data)
             if isinstance(data, str):
                 import base64
-                return base64.b64decode(data)
+                return base64.b64encode(bytes()) if data == "" else base64.b64decode(data)
         except Exception:
             return None
         return None
@@ -1004,4 +1006,55 @@ class Chat:
                     out.append({"type": typ, "uri": uri})
                 continue
 
-        return out
+        return out
+
+    def _maybe_download_response_files(self, response, ctx: CtxItem) -> None:
+        """
+        Inspect non-stream response parts for Files API references and download them.
+        """
+        try:
+            cands = getattr(response, "candidates", None) or []
+            if not cands:
+                return
+            first = cands[0]
+            content = getattr(first, "content", None)
+            parts = getattr(content, "parts", None) or []
+        except Exception:
+            parts = []
+
+        if not parts:
+            return
+
+        downloaded: List[str] = []
+        for p in parts:
+            fdata = getattr(p, "file_data", None)
+            if not fdata:
+                continue
+            try:
+                uri = getattr(fdata, "file_uri", None) or getattr(fdata, "uri", None)
+                prefer = getattr(fdata, "file_name", None) or getattr(fdata, "display_name", None)
+                if not uri or not isinstance(uri, str):
+                    continue
+                # Only Gemini Files API refs are supported for direct download
+                save_path = self.window.core.api.google.store.download_to_dir(uri, prefer_name=prefer)
+                if save_path:
+                    downloaded.append(save_path)
+            except Exception:
+                continue
+
+        if downloaded:
+            downloaded = self.window.core.filesystem.make_local_list(downloaded)
+            if not isinstance(ctx.files, list):
+                ctx.files = []
+            for path in downloaded:
+                if path not in ctx.files:
+                    ctx.files.append(path)
+            images = []
+            for path in downloaded:
+                ext = os.path.splitext(path)[1].lower().lstrip(".")
+                if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                    images.append(path)
+            if images:
+                if not isinstance(ctx.images, list):
+                    ctx.images = []
+                ctx.images += images