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

pygpt_net/provider/api/anthropic/remote_tools.py

@@ -0,0 +1,172 @@
+#!/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                  #
+# ================================================== #
+
+import json
+from typing import List, Any, Dict, Optional
+
+from pygpt_net.item.model import ModelItem
+
+class RemoteTools:
+    def __init__(self, window=None):
+        """
+        Remote tools mapper for Anthropic Messages API.
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    def build_remote_tools(self, model: ModelItem = None) -> List[dict]:
+        """
+        Build Anthropic server tools (remote tools) based on config flags.
+        Supports: Web Search, Code Execution, Web Fetch, Tool Search, MCP toolset.
+
+        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] = []
+
+        # keep compatibility with previous models that had no remote tool support
+        if model and model.id and model.id.startswith("claude-3-5"):
+            # remote tool availability on 3.5 models varies; previous behavior was to skip
+            return tools
+
+        # Helper: bool from config with provider-specific fallback
+        def cfg_bool(*keys: str, default: bool = False) -> bool:
+            for k in keys:
+                v = cfg.get(k)
+                if isinstance(v, bool):
+                    return v
+            return default
+
+        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()]
+
+        # --- Web Search (server tool) ---
+        is_web = self.window.controller.chat.remote_tools.enabled(model, "web_search")
+        if is_web:
+            ttype = cfg.get("remote_tools.anthropic.web_search.type", "web_search_20250305")
+            tname = "web_search"
+            tool_def: Dict[str, Any] = {
+                "type": ttype,
+                "name": tname,
+            }
+            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
+            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
+            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,
+                }
+                tool_def["user_location"] = {k: v for k, v in tool_def["user_location"].items() if v is not None}
+            tools.append(tool_def)
+
+        # --- Code Execution (server tool) ---
+        is_code_exec = cfg_bool("remote_tools.anthropic.code_execution", default=False)
+        if is_code_exec:
+            tools.append({
+                "type": "code_execution_20250825",
+                "name": "code_execution",
+            })
+
+        # --- Web Fetch (server tool) ---
+        is_web_fetch = cfg_bool("remote_tools.anthropic.web_fetch", default=False)
+        if is_web_fetch:
+            fetch_def: Dict[str, Any] = {
+                "type": "web_fetch_20250910",
+                "name": "web_fetch",
+            }
+            max_uses = cfg.get("remote_tools.anthropic.web_fetch.max_uses")
+            if isinstance(max_uses, int) and max_uses > 0:
+                fetch_def["max_uses"] = max_uses
+            allowed = parse_csv_list("remote_tools.anthropic.web_fetch.allowed_domains")
+            blocked = parse_csv_list("remote_tools.anthropic.web_fetch.blocked_domains")
+            if allowed:
+                fetch_def["allowed_domains"] = allowed
+            elif blocked:
+                fetch_def["blocked_domains"] = blocked
+            citations_enabled = cfg_bool("remote_tools.anthropic.web_fetch.citations.enabled", default=True)
+            if citations_enabled:
+                fetch_def["citations"] = {"enabled": True}
+            max_content_tokens = cfg.get("remote_tools.anthropic.web_fetch.max_content_tokens")
+            if isinstance(max_content_tokens, int) and max_content_tokens > 0:
+                fetch_def["max_content_tokens"] = max_content_tokens
+            tools.append(fetch_def)
+
+        # --- Tool Search (server tool) ---
+        """
+        is_tool_search = cfg_bool("remote_tools.anthropic.tool_search", default=False)
+        if is_tool_search:
+            variant = (cfg.get("remote_tools.anthropic.tool_search.variant")
+                       or cfg.get("remote_tools.tool_search.variant") or "regex")
+            # accept full type as well
+            raw_type = str(cfg.get("remote_tools.anthropic.tool_search.type")
+                           or cfg.get("remote_tools.tool_search.type") or "").strip()
+            if raw_type.startswith("tool_search_tool_"):
+                ttype = raw_type
+                tname = "tool_search_tool_regex" if "regex" in raw_type else "tool_search_tool_bm25"
+            else:
+                if str(variant).lower() == "bm25":
+                    ttype = "tool_search_tool_bm25_20251119"
+                    tname = "tool_search_tool_bm25"
+                else:
+                    ttype = "tool_search_tool_regex_20251119"
+                    tname = "tool_search_tool_regex"
+            tools.append({
+                "type": ttype,
+                "name": tname,
+            })
+        """
+
+        # --- MCP toolset (server-side tool catalog from MCP servers) ---
+        is_mcp = cfg_bool("remote_tools.anthropic.mcp", default=False)
+        if is_mcp:
+            raw_tools = cfg.get("remote_tools.anthropic.mcp.tools")
+            if raw_tools:
+                try:
+                    if isinstance(raw_tools, (list, dict)):
+                        mcp_tools = raw_tools
+                    else:
+                        mcp_tools = json.loads(raw_tools)
+                    # ensure list
+                    if isinstance(mcp_tools, dict):
+                        mcp_tools = [mcp_tools]
+                    for t in mcp_tools:
+                        if isinstance(t, dict):
+                            # default type if not set
+                            if "type" not in t:
+                                t["type"] = "mcp_toolset"
+                            tools.append(t)
+                except Exception:
+                    pass  # ignore invalid JSON to avoid breaking existing flows
+
+        return tools

pygpt_net/provider/api/anthropic/store.py

@@ -0,0 +1,307 @@
+#!/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                  #
+# ================================================== #
+
+import os
+import mimetypes
+import time
+from typing import Optional, List, Dict, Any
+
+from .worker.importer import Importer
+
+
+class Store:
+    """
+    Anthropic Files API wrapper.
+    """
+
+    # Files API is in beta and requires this header, per official docs
+    # https://docs.anthropic.com/en/docs/build-with-claude/files
+    BETA_HEADER = ["files-api-2025-04-14"]
+
+    def __init__(self, window=None):
+        """
+        Anthropic Files API store wrapper
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.importer = Importer(window)
+
+    def get_client(self):
+        """
+        Get Anthropic client
+
+        :return: anthropic.Anthropic
+        """
+        return self.window.core.api.anthropic.get_client()
+
+    def log(self, msg: str, callback: Optional[callable] = None):
+        """
+        Log message
+
+        :param msg: message to log
+        :param callback: callback log function
+        """
+        if callback is not None:
+            callback(msg)
+        else:
+            print(msg)
+
+    def _download_dir(self) -> str:
+        """
+        Resolve target download directory (uses download.dir if set).
+        """
+        if self.window.core.config.has("download.dir") and self.window.core.config.get("download.dir") != "":
+            dir_path = os.path.join(
+                self.window.core.config.get_user_dir('data'),
+                self.window.core.config.get("download.dir"),
+            )
+        else:
+            dir_path = self.window.core.config.get_user_dir('data')
+        os.makedirs(dir_path, exist_ok=True)
+        return dir_path
+
+    def _ensure_unique_path(self, dir_path: str, filename: str) -> str:
+        """
+        Ensure unique filename in dir, add timestamp prefix if exists.
+        """
+        path = os.path.join(dir_path, filename)
+        if os.path.exists(path):
+            prefix = time.strftime("%Y%m%d_%H%M%S_")
+            path = os.path.join(dir_path, f"{prefix}{filename}")
+        return path
+
+    # -----------------------------
+    # Files service
+    # -----------------------------
+
+    def get_file(self, file_id: str):
+        """
+        Retrieve file metadata by ID using the SDK method names present in the installed version.
+        Prefer 'retrieve', fallback to 'get' only if available to avoid attribute errors.
+        """
+        client = self.get_client()
+        files_api = client.beta.files
+        if hasattr(files_api, "retrieve"):
+            return files_api.retrieve(file_id, betas=self.BETA_HEADER)
+        if hasattr(files_api, "get"):
+            return files_api.get(file_id, betas=self.BETA_HEADER)
+        raise AttributeError("Anthropic Files API client does not expose 'retrieve' or 'get' for file metadata.")
+
+    def upload(self, path: str):
+        """
+        Upload file to Anthropic Files API.
+
+        Per SDK guidance, the Python client supports passing a PathLike, raw bytes,
+        or a (filename, contents, media_type) tuple. Using the tuple form ensures the
+        correct filename and MIME type are sent in multipart/form-data.
+
+        :param path: file path
+        :return: file object or None
+        """
+        client = self.get_client()
+        if not os.path.exists(path):
+            return None
+
+        filename = os.path.basename(path)
+        mime_type = mimetypes.guess_type(path)[0] or "application/octet-stream"
+        with open(path, "rb") as f:
+            data = f.read()
+        file_part = (filename, data, mime_type)
+
+        files_api = client.beta.files
+
+        try:
+            return files_api.upload(file=file_part, betas=self.BETA_HEADER)
+        except Exception:
+            if hasattr(files_api, "create"):
+                return files_api.create(file=file_part, betas=self.BETA_HEADER)
+            raise
+
+    def delete_file(self, file_id: str) -> Optional[str]:
+        """
+        Delete a file by ID. Returns the file_id on success.
+        """
+        client = self.get_client()
+        res = client.beta.files.delete(file_id, betas=self.BETA_HEADER)
+        if res is not None:
+            return file_id
+
+    def download(self, file_id: str, path: str) -> bool:
+        """
+        Download a file content to a local path.
+
+        :param file_id: Anthropic Files API file id
+        :param path: target file path
+        :return: True on success
+        """
+        client = self.get_client()
+        try:
+            # SDK returns raw bytes for file content
+            data = client.beta.files.content(file_id, betas=self.BETA_HEADER)
+        except Exception:
+            data = None
+
+        if data is None:
+            return False
+
+        try:
+            if hasattr(data, "read"):
+                content = data.read()
+            else:
+                content = data if isinstance(data, (bytes, bytearray)) else bytes(data)
+            with open(path, "wb") as f:
+                f.write(content)
+            return True
+        except Exception:
+            return False
+
+    def download_to_dir(self, file_id: str, prefer_name: Optional[str] = None) -> Optional[str]:
+        """
+        Download a file by ID into configured download directory.
+
+        :param file_id: Anthropic Files API file id
+        :param prefer_name: optional filename preference
+        :return: saved file path or None
+        """
+        dir_path = self._download_dir()
+        filename = None
+
+        if prefer_name:
+            filename = os.path.basename(prefer_name)
+
+        if not filename:
+            try:
+                meta = self.get_file(file_id)
+            except Exception:
+                meta = None
+            if meta is not None:
+                for attr in ("filename", "name", "id"):
+                    try:
+                        val = getattr(meta, attr, None)
+                        if isinstance(val, str) and val:
+                            filename = os.path.basename(val)
+                            break
+                    except Exception:
+                        pass
+                if not filename:
+                    filename = file_id
+            else:
+                filename = file_id
+
+        if not os.path.splitext(filename)[1] and meta is not None:
+            try:
+                mime = getattr(meta, "mime_type", None)
+                ext = mimetypes.guess_extension(mime or "") or ""
+                if ext and not filename.endswith(ext):
+                    filename = filename + ext
+            except Exception:
+                pass
+
+        path = self._ensure_unique_path(dir_path, filename)
+        if self.download(file_id, path):
+            return path
+        return None
+
+    def get_files_ids(self, limit: int = 1000) -> List[str]:
+        """
+        Return a list of file IDs. Falls back to filename only if id is missing.
+        """
+        client = self.get_client()
+        items: List[str] = []
+        pager = client.beta.files.list(limit=limit, betas=self.BETA_HEADER)
+
+        data = getattr(pager, "data", None)
+        if data is None:
+            data = pager
+
+        for f in data:
+            fid = getattr(f, "id", None) or getattr(f, "filename", None)
+            if fid and fid not in items:
+                items.append(fid)
+        return items
+
+    def remove_files(self, callback: Optional[callable] = None) -> int:
+        """
+        Remove all files from remote storage. Returns number of successfully removed files.
+        """
+        num = 0
+        files = self.get_files_ids()
+        for file_id in files:
+            self.log("Removing file: " + file_id, callback)
+            try:
+                res = self.delete_file(file_id)
+                if res:
+                    num += 1
+            except Exception as e:
+                msg = "Error removing file {}: {}".format(file_id, str(e))
+                self.log(msg, callback)
+        return num
+
+    def remove_file(self, file_id: str, callback: Optional[callable] = None) -> bool:
+        """
+        Remove a single file by ID. Raises on errors to allow upstream handling.
+        """
+        self.log("Removing file: " + file_id, callback)
+        try:
+            res = self.delete_file(file_id)
+            return res is not None
+        except Exception as e:
+            msg = "Error removing file {}: {}".format(file_id, str(e))
+            self.log(msg, callback)
+            raise
+
+    def import_files(self, callback: Optional[callable] = None) -> int:
+        """
+        Import all files from Anthropic Files API into local DB.
+
+        :param callback: log callback
+        :return: number of imported files
+        """
+        client = self.get_client()
+        total = 0
+        pager = client.beta.files.list(limit=1000, betas=self.BETA_HEADER)
+
+        data = getattr(pager, "data", None)
+        if data is None:
+            data = pager
+
+        for f in data:
+            try:
+                self.window.core.remote_store.anthropic.files.insert("files", f)
+                total += 1
+            except Exception as e:
+                self.log("Error importing file {}: {}".format(getattr(f, "id", "?"), e), callback)
+        return total
+
+    def get_files_stats(self) -> Dict[str, Any]:
+        """
+        Compute files stats (count + total bytes).
+        """
+        client = self.get_client()
+        count = 0
+        total_bytes = 0
+        pager = client.beta.files.list(limit=1000, betas=self.BETA_HEADER)
+
+        data = getattr(pager, "data", None)
+        if data is None:
+            data = pager
+
+        for f in data:
+            count += 1
+            try:
+                size = getattr(f, "size_bytes", None)
+                if size is None and hasattr(f, "size"):
+                    size = getattr(f, "size")
+                total_bytes += int(size or 0)
+            except Exception:
+                pass
+        return {"count": count, "total_bytes": total_bytes}

pygpt_net/{controller/chat/handler/anthropic_stream.py → provider/api/anthropic/stream.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 00:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import io
@@ -28,6 +28,82 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
     state.usage_vendor = "anthropic"
     etype = str(getattr(chunk, "type", "") or "")
     response: Optional[str] = None
+    is_computer_call = False
+
+    # Computer Use: translate Anthropic 'computer' tool_use stream into plugin calls
+    try:
+        tool_calls, has_calls = core.api.anthropic.computer.handle_stream_chunk(ctx, chunk, state.tool_calls)
+        state.tool_calls = tool_calls
+        if has_calls:
+            is_computer_call = True
+            state.force_func_call = True
+    except Exception:
+        pass
+
+    def _to_plain(obj):
+        try:
+            if hasattr(obj, "model_dump"):
+                return obj.model_dump()
+            if hasattr(obj, "to_dict"):
+                return obj.to_dict()
+        except Exception:
+            pass
+        if isinstance(obj, dict):
+            return {k: _to_plain(v) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [_to_plain(x) for x in obj]
+        return obj
+
+    def _walk_for_file_ids(o, acc: set):
+        if o is None:
+            return
+        if isinstance(o, dict):
+            for k, v in o.items():
+                if k == "file_id" and isinstance(v, str) and v.startswith("file_"):
+                    acc.add(v)
+                else:
+                    _walk_for_file_ids(v, acc)
+        elif isinstance(o, (list, tuple)):
+            for it in o:
+                _walk_for_file_ids(it, acc)
+
+    def _download_files(ids: set):
+        if not ids:
+            return
+        if not hasattr(state, "anthropic_downloaded_ids"):
+            state.anthropic_downloaded_ids = set()
+        saved = []
+        for fid in ids:
+            if fid in state.anthropic_downloaded_ids:
+                continue
+            try:
+                path = core.api.anthropic.store.download_to_dir(fid)
+            except Exception:
+                path = None
+            if path:
+                saved.append(path)
+                state.anthropic_downloaded_ids.add(fid)
+        if saved:
+            try:
+                loc = core.filesystem.make_local_list(saved)
+            except Exception:
+                loc = saved
+            if not isinstance(ctx.files, list):
+                ctx.files = []
+            for p in loc:
+                if p not in ctx.files:
+                    ctx.files.append(p)
+            imgs = []
+            for p in loc:
+                ext = p.lower().rsplit(".", 1)[-1] if "." in p else ""
+                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)
 
     # --- Top-level delta objects (when SDK yields deltas directly) ---
     if etype == "text_delta":
@@ -37,7 +113,7 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
     if etype == "thinking_delta":
         return None
 
-    if etype == "input_json_delta":
+    if etype == "input_json_delta" and not is_computer_call:
         pj = getattr(chunk, "partial_json", "") or ""
         buf = state.fn_args_buffers.get("__anthropic_last__")
         if buf is None:
@@ -64,23 +140,36 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
             pass
         return None
 
-    if etype == "content_block_start":
+    if etype == "content_block_start" and not is_computer_call:
         try:
             cb = getattr(chunk, "content_block", None)
             if cb and getattr(cb, "type", "") == "tool_use":
                 idx = getattr(chunk, "index", 0) or 0
                 tid = getattr(cb, "id", "") or ""
                 name = getattr(cb, "name", "") or ""
-                state.tool_calls.append({
-                    "id": tid,
-                    "type": "function",
-                    "function": {"name": name, "arguments": ""}
-                })
+                # Skip generic function-call for Anthropic Computer Use; the adapter will emit computer_call items.
+                if name not in {"computer", "computer.use", "anthropic/computer", "computer_use", "computer-use"}:
+                    state.tool_calls.append({
+                        "id": tid,
+                        "type": "function",
+                        "function": {"name": name, "arguments": ""}
+                    })
                 state.fn_args_buffers[str(idx)] = io.StringIO()
                 state.fn_args_buffers["__anthropic_last__"] = state.fn_args_buffers[str(idx)]
         except Exception:
             pass
 
+        try:
+            cb = getattr(chunk, "content_block", None)
+            if cb:
+                btype = getattr(cb, "type", "") or ""
+                if btype.endswith("_tool_result"):
+                    ids = set()
+                    _walk_for_file_ids(_to_plain(getattr(cb, "content", None)), ids)
+                    _download_files(ids)
+        except Exception:
+            pass
+
         try:
             cb = getattr(chunk, "content_block", None)
             if cb and getattr(cb, "type", "") == "web_search_tool_result":
@@ -97,7 +186,7 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
 
         return None
 
-    if etype == "content_block_delta":
+    if etype == "content_block_delta" and not is_computer_call:
         try:
             delta = getattr(chunk, "delta", None)
             if not delta:
@@ -125,7 +214,7 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
             pass
         return response
 
-    if etype == "content_block_stop":
+    if etype == "content_block_stop" and not is_computer_call:
         try:
             idx = str(getattr(chunk, "index", 0) or 0)
             buf = state.fn_args_buffers.pop(idx, None)