pygpt-net 2.7.5__py3-none-any.whl → 2.7.7__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/{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,18 @@ 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
+
 
     # --- Top-level delta objects (when SDK yields deltas directly) ---
     if etype == "text_delta":
@@ -37,7 +49,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,18 +76,20 @@ 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:
@@ -97,7 +111,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 +139,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)

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/google/__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.02 19:00:00                  #
+# Updated Date: 2026.01.03 17:00:00                  #
 # ================================================== #
 
 import os
@@ -25,6 +25,7 @@ from pygpt_net.core.types import (
     MODE_COMPUTER,
 )
 from pygpt_net.core.bridge.context import BridgeContext
+from pygpt_net.core.types.chunk import ChunkType
 from pygpt_net.item.model import ModelItem
 
 from .chat import Chat
@@ -124,10 +125,7 @@ class ApiGoogle:
         stream = context.stream
         ctx = context.ctx
         ai_name = ctx.output_name if ctx else "assistant"
-
-        # No Responses API in google-genai
-        if ctx:
-            ctx.use_responses_api = False
+        ctx.chunk_type = ChunkType.GOOGLE
 
         used_tokens = 0
         response = None
@@ -151,6 +149,9 @@ class ApiGoogle:
                 if is_realtime:
                     return True
 
+            if mode == MODE_RESEARCH:
+                ctx.chunk_type = ChunkType.GOOGLE_INTERACTIONS_API  # use interactions API for research
+
             response = self.chat.send(context=context, extra=extra)
             used_tokens = self.chat.get_used_tokens()
             if ctx:

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 02:10: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:
@@ -180,7 +176,6 @@ class Chat:
         params = dict(model=model.id, contents=inputs, config=cfg)
 
         if mode == MODE_RESEARCH:
-            ctx.use_google_interactions_api = True
 
             # Deep Research does not support audio inputs; if an audio snippet is present, transcribe it to text first.
             if has_audio_input:

pygpt_net/{controller/chat/handler/google_stream.py → provider/api/google/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 02:10:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import base64