pygpt-net 2.6.36__py3-none-any.whl → 2.6.38__py3-none-any.whl

pygpt_net/provider/api/anthropic/tools.py

@@ -0,0 +1,266 @@
+#!/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: 2025.09.05 01:00:00                  #
+# ================================================== #
+
+import json
+from typing import List, Any, Dict, Optional
+
+from pygpt_net.item.model import ModelItem
+
+
+class Tools:
+    def __init__(self, window=None):
+        """
+        Tools mapper for Anthropic Messages API.
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    def _sanitize_schema(self, schema: Any) -> Any:
+        """
+        Sanitize JSON Schema dict for Anthropic input_schema.
+
+        - Remove unsupported or risky keywords.
+        - Normalize 'type'.
+        - Ensure properties/items recursively valid.
+
+        :param schema: JSON Schema (dict or list)
+        :return: Sanitized JSON Schema (dict)
+        """
+        # 1) entry point: if list, take the first element
+        if isinstance(schema, list):
+            # If it's a list of schemas/types, take the first one (after filtering out empty ones)
+            return self._sanitize_schema(schema[0]) if schema else {}
+
+        if not isinstance(schema, dict):
+            return schema
+
+        # 2) remove unsupported keys
+        banned = {
+            "unevaluatedProperties",
+            "$defs", "$ref", "$schema", "$id",
+            "examples", "readOnly", "writeOnly", "nullable",
+            "dependentSchemas", "dependentRequired",
+            "oneOf", "anyOf", "allOf", "patternProperties", "dependencies",
+            "additional_properties",  # underscore
+            "additionalProperties",  # camelCase
+        }
+        for k in list(schema.keys()):
+            if k in banned:
+                schema.pop(k, None)
+
+        # 3) normalize 'type'
+        t = schema.get("type")
+
+        # a) list of types -> take the first non-null
+        if isinstance(t, list):
+            t_no_null = [x for x in t if isinstance(x, str) and x.lower() != "null"]
+            schema["type"] = t_no_null[0] if t_no_null else "object"
+            t = schema["type"]
+
+        # b) if 'type' is not a string (e.g., dict), try to infer or remove it
+        if not isinstance(t, str):
+            if "properties" in schema:
+                schema["type"] = "object"
+            elif "items" in schema:
+                schema["type"] = "array"
+            elif "enum" in schema and isinstance(schema["enum"], list) and all(
+                    isinstance(x, str) for x in schema["enum"]):
+                schema["type"] = "string"
+            else:
+                # no reasonable type — leave without 'type' and continue
+                schema.pop("type", None)
+        else:
+            schema["type"] = t.lower()
+
+        # Safe form of type for further comparisons
+        t_val = schema.get("type")
+        type_l = t_val.lower() if isinstance(t_val, str) else ""
+
+        # 4) enum only for string
+        if "enum" in schema and type_l != "string":
+            schema.pop("enum", None)
+
+        # 5) Object
+        if type_l == "object":
+            props = schema.get("properties")
+            if not isinstance(props, dict):
+                props = {}
+            clean_props: Dict[str, Any] = {}
+            for pname, pval in props.items():
+                clean_props[pname] = self._sanitize_schema(pval)
+            schema["properties"] = clean_props
+
+            req = schema.get("required")
+            if not (isinstance(req, list) and all(isinstance(x, str) for x in req) and len(req) > 0):
+                schema.pop("required", None)
+
+        # 6) Array
+        elif type_l == "array":
+            items = schema.get("items")
+            if isinstance(items, list):
+                items = items[0] if items else {"type": "string"}
+            if not isinstance(items, dict):
+                items = {"type": "string"}
+            schema["items"] = self._sanitize_schema(items)
+
+        # 7) Recursion over remaining nestings,
+        #    but skip 'properties' and 'items' — we've already sanitized them
+        for k, v in list(schema.items()):
+            if k in ("properties", "items"):
+                continue
+            if isinstance(v, dict):
+                schema[k] = self._sanitize_schema(v)
+            elif isinstance(v, list):
+                schema[k] = [self._sanitize_schema(x) for x in v]
+
+        return schema
+
+    def prepare(self, model: ModelItem, functions: list) -> List[dict]:
+        """
+        Prepare Anthropic tool definitions: [{"name","description","input_schema"}].
+
+        :param model: ModelItem
+        :param functions: List of app function dicts
+        :return: List of tool dicts for Anthropic
+        """
+        if not functions or not isinstance(functions, list):
+            return []
+
+        tools: List[dict] = []
+        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"
+
+            tools.append({
+                "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
+
+        # Web Search tool
+        if cfg.get("remote_tools.anthropic.web_search"):
+            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}
+
+            tools.append(tool_def)
+
+        return tools
+
+    def merge_tools_dedup(self, primary: List[dict], secondary: List[dict]) -> List[dict]:
+        """
+        Remove duplicate tools by name, preserving order:
+
+        - First from primary list
+        - Then from secondary list if name not already present
+
+        :param primary: Primary list of tool dicts
+        :param secondary: Secondary list of tool dicts
+        :return: Merged list of tool dicts without duplicates
+        """
+        result: List[dict] = []
+        seen = set()
+        for t in primary or []:
+            n = t.get("name")
+            if n and n not in seen:
+                seen.add(n)
+                result.append(t)
+        for t in secondary or []:
+            n = t.get("name")
+            if not n or n in seen:
+                continue
+            seen.add(n)
+            result.append(t)
+        return result
+
+    def get_all_tools(self, model: ModelItem, functions: list) -> List[dict]:
+        """
+        Get combined list of all tools (app functions + remote tools) for Anthropic.
+
+        :param model: ModelItem
+        :param functions: List of app function dicts
+        :return: Combined list of tool dicts
+        """
+        base_tools = self.prepare(model, functions)
+        remote_tools = self.build_remote_tools(model)
+        return self.merge_tools_dedup(base_tools, remote_tools)

pygpt_net/provider/api/anthropic/vision.py

@@ -0,0 +1,142 @@
+#!/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: 2025.09.05 01:00:00                  #
+# ================================================== #
+
+import base64
+import os
+from typing import Optional, Dict, List, Union
+
+from pygpt_net.item.attachment import AttachmentItem
+from pygpt_net.item.ctx import CtxItem
+
+
+class Vision:
+    def __init__(self, window=None):
+        """
+        Vision helpers for Anthropic (image input blocks).
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.attachments: Dict[str, str] = {}
+        self.urls: List[str] = []
+        self.input_tokens = 0
+
+    def build_blocks(
+        self,
+        content: Union[str, list],
+        attachments: Optional[Dict[str, AttachmentItem]] = None,
+    ) -> List[dict]:
+        """
+        Build image content blocks from local attachments.
+
+        :param content: User message text (unused here)
+        :param attachments: Attachments dict (id -> AttachmentItem)
+        :return: List of Anthropic content blocks
+        """
+        blocks: List[dict] = []
+        self.attachments = {}
+        self.urls = []
+
+        if attachments:
+            for id_, attachment in attachments.items():
+                if attachment.path and os.path.exists(attachment.path):
+                    if self.is_image(attachment.path):
+                        mime = self._guess_mime(attachment.path)
+                        with open(attachment.path, "rb") as f:
+                            data = f.read()
+                        b64 = base64.b64encode(data).decode("utf-8")
+                        blocks.append({
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": mime,
+                                "data": b64,
+                            }
+                        })
+                        self.attachments[id_] = attachment.path
+                        attachment.consumed = True
+
+        return blocks
+
+    def is_image(self, path: str) -> bool:
+        """
+        Check if path looks like an image.
+
+        :param path: File path
+        :return: True if path has image file extension
+        """
+        return path.lower().endswith(('.png', '.jpg', '.jpeg', '.tiff', '.bmp', '.gif', '.webp'))
+
+    def _guess_mime(self, path: str) -> str:
+        """
+        Guess mime type from file extension.
+
+        :param path: File path
+        :return: MIME type string
+        """
+        ext = os.path.splitext(path)[1].lower().lstrip(".")
+        if ext in ("jpg", "jpeg"):
+            return "image/jpeg"
+        if ext == "png":
+            return "image/png"
+        if ext == "gif":
+            return "image/gif"
+        if ext == "bmp":
+            return "image/bmp"
+        if ext == "webp":
+            return "image/webp"
+        if ext == "tiff":
+            return "image/tiff"
+        return "image/jpeg"
+
+    def append_images(self, ctx: CtxItem):
+        """
+        Append sent images paths to context for UI/history.
+
+        :param ctx: CtxItem
+        """
+        images = self.get_attachments()
+        if len(images) > 0:
+            ctx.images = self.window.core.filesystem.make_local_list(list(images.values()))
+
+    def get_attachments(self) -> Dict[str, str]:
+        """
+        Return attachments dict (id -> path).
+
+        :return: Attachments dictionary
+        """
+        return self.attachments
+
+    def get_urls(self) -> List[str]:
+        """
+        Return image urls (unused).
+
+        :return: List of image URLs
+        """
+        return self.urls
+
+    def reset_tokens(self):
+        """Reset input tokens counter."""
+        self.input_tokens = 0
+
+    def get_used_tokens(self) -> int:
+        """
+        Return input tokens counter.
+
+        :return: Number of input tokens
+        """
+        return self.input_tokens
+
+    def reset(self):
+        """Reset state."""
+        self.attachments = {}
+        self.urls = []
+        self.input_tokens = 0

pygpt_net/provider/api/google/chat.py

@@ -401,8 +401,7 @@ class Chat:
                             # Store only as URL; downloading is out of scope here.
                             if uri.startswith("http://") or uri.startswith("https://"):
                                 urls.append(uri)
-        except Exception:
-            # Best-effort only
+        except Exception as e:
             pass
 
         if images:
@@ -497,6 +496,7 @@ class Chat:
         :param multimodal_ctx: MultimodalContext for audio
         :return: List of Part
         """
+        self.window.core.api.google.vision.reset()
         parts: List[Part] = []
         if content:
             parts.append(Part.from_text(text=str(content)))

pygpt_net/provider/api/google/realtime/client.py

@@ -890,7 +890,7 @@ class GoogleLiveClient:
                                         "arguments": json.dumps(args_dict, ensure_ascii=False),
                                     }
                                 })
-                                self._rt_state["force_func_call"] = True
+                                # self._rt_state["force_func_call"] = True
                                 self._last_tool_calls = list(self._rt_state["tool_calls"])
                                 turn_finished = True  # let the app run tools now
 
@@ -1004,7 +1004,7 @@ class GoogleLiveClient:
                             if key not in seen:
                                 self._rt_state["tool_calls"].append(c)
                                 seen.add(key)
-                        self._rt_state["force_func_call"] = True
+                        # self._rt_state["force_func_call"] = True
                         self._last_tool_calls = list(self._rt_state["tool_calls"])
                     turn_finished = True
 

pygpt_net/provider/api/google/tools.py

@@ -28,61 +28,70 @@ class Tools:
     # -------- SANITIZER --------
     def _sanitize_schema(self, schema: Any) -> Any:
         """
-        Sanitize JSON Schema dict by removing unsupported keywords and normalizing types.
-
-        1. Remove unsupported keywords like additionalProperties, patternProperties,
-           dependencies, oneOf, anyOf, allOf, $ref, $defs, examples, readOnly, writeOnly.
-        2. Normalize 'type' to a single value (e.g., if it's a list, take the first non-null type).
-        3. Ensure 'enum' is only present for string types.
-        4. Recursively sanitize nested schemas in 'properties' and 'items'.
-        5. Handle arrays by ensuring 'items' is a single schema.
-        6. Handle objects by ensuring 'properties' is a dict and 'required' is a list of strings.
-
-        :param schema: Any JSON Schema as dict or list
-        :return: Sanitized schema dict
+        Sanitize a JSON Schema dict for Google GenAI (function parameters).
+
+        Key points:
+        - Remove unsupported JSON Schema keywords (additionalProperties, oneOf, $ref, ...).
+        - Normalize "type" so that it's either a single lowercase string or absent.
+          Handle lists (unions), non-string types (e.g., dict), and infer a type when possible.
+        - Keep "enum" only when type is string.
+        - For objects, sanitize only "properties" (each property's schema) and validate "required".
+        - For arrays, sanitize "items" into a single schema (object, not list).
+        - Do not recurse into "properties" itself as a map, nor into "required"/"enum" as they are scalars/lists.
         """
+        # 1) Fast exits
         if isinstance(schema, list):
-            return self._sanitize_schema(schema[0]) if schema else {}
+            # Only descend into lists of dicts (complex schemas). For scalar lists (required/enum), return as is.
+            if schema and all(isinstance(x, dict) for x in schema):
+                return [self._sanitize_schema(x) for x in schema]
+            return schema
 
         if not isinstance(schema, dict):
             return schema
 
+        # 2) Remove unsupported/problematic keywords for Google function parameters
         banned = {
-            "additionalProperties",
-            "additional_properties",
-            "unevaluatedProperties",
-            "patternProperties",
-            "dependencies",
-            "dependentSchemas",
-            "dependentRequired",
-            "oneOf",
-            "anyOf",
-            "allOf",
-            "$defs",
-            "$ref",
-            "$schema",
-            "$id",
-            "examples",
-            "readOnly",
-            "writeOnly",
-            "nullable",
+            "additionalProperties", "additional_properties",
+            "unevaluatedProperties", "patternProperties",
+            "dependencies", "dependentSchemas", "dependentRequired",
+            "oneOf", "anyOf", "allOf",
+            "$defs", "$ref", "$schema", "$id",
+            "examples", "readOnly", "writeOnly", "nullable",
         }
         for k in list(schema.keys()):
             if k in banned:
                 schema.pop(k, None)
 
-        # Union -> first non-null type
+        # 3) Normalize "type" safely
         t = schema.get("type")
-        if isinstance(t, list):
-            t_no_null = [x for x in t if x != "null"]
-            schema["type"] = t_no_null[0] if t_no_null else "string"
 
-        # enum only for string
-        if "enum" in schema and schema.get("type") not in ("string", "STRING"):
+        # a) If it's a list (union), pick the first non-null string, otherwise default to "object"
+        if isinstance(t, list):
+            t_no_null = [x for x in t if isinstance(x, str) and x.lower() != "null"]
+            schema["type"] = t_no_null[0] if t_no_null else "object"
+            t = schema["type"]
+
+        # b) If "type" is not a string (could be dict or missing), try to infer; otherwise drop it
+        if not isinstance(t, str):
+            if isinstance(schema.get("properties"), dict):
+                schema["type"] = "object"
+            elif "items" in schema:
+                schema["type"] = "array"
+            elif isinstance(schema.get("enum"), list) and all(isinstance(x, str) for x in schema["enum"]):
+                schema["type"] = "string"
+            else:
+                schema.pop("type", None)
+        else:
+            schema["type"] = t.lower()
+
+        type_l = schema["type"].lower() if isinstance(schema.get("type"), str) else ""
+
+        # 4) Keep enum only for string-typed schemas
+        if "enum" in schema and type_l != "string":
             schema.pop("enum", None)
 
-        # object
-        if (schema.get("type") or "").lower() == "object":
+        # 5) Objects: sanitize properties and required
+        if type_l == "object":
             props = schema.get("properties")
             if not isinstance(props, dict):
                 props = {}
@@ -92,25 +101,26 @@ class Tools:
             schema["properties"] = clean_props
 
             req = schema.get("required")
-            if not isinstance(req, list) or not all(isinstance(x, str) for x in req):
-                schema.pop("required", None)
-            elif len(req) == 0:
+            if not (isinstance(req, list) and all(isinstance(x, str) for x in req) and len(req) > 0):
                 schema.pop("required", None)
 
-        # array
-        if (schema.get("type") or "").lower() == "array":
+        # 6) Arrays: ensure "items" is a single dict schema
+        elif type_l == "array":
             items = schema.get("items")
-            if isinstance(items, list) and items:
-                items = items[0]
+            if isinstance(items, list):
+                items = items[0] if items else {"type": "string"}
             if not isinstance(items, dict):
                 items = {"type": "string"}
             schema["items"] = self._sanitize_schema(items)
 
-        # recursive sanitize
+        # 7) Recurse into the remaining nested dict/list values,
+        #    but skip "properties", "items", "required", and "enum" (already handled)
         for k, v in list(schema.items()):
+            if k in ("properties", "items", "required", "enum"):
+                continue
             if isinstance(v, dict):
                 schema[k] = self._sanitize_schema(v)
-            elif isinstance(v, list):
+            elif isinstance(v, list) and v and all(isinstance(x, dict) for x in v):
                 schema[k] = [self._sanitize_schema(x) for x in v]
 
         return schema

pygpt_net/provider/api/google/vision.py

@@ -126,4 +126,10 @@ class Vision:
 
         :return: Number of input tokens
         """
-        return self.input_tokens
+        return self.input_tokens
+
+    def reset(self):
+        """Reset state"""
+        self.attachments = {}
+        self.urls = []
+        self.input_tokens = 0

pygpt_net/provider/api/openai/chat.py

@@ -177,6 +177,7 @@ class Chat:
         :param multimodal_ctx: Multimodal context
         :return: messages list
         """
+        self.window.core.api.openai.vision.reset()
         messages = []
 
         # tokens config

pygpt_net/provider/api/openai/vision.py

@@ -369,6 +369,12 @@ class Vision:
         """Reset input tokens counter"""
         self.input_tokens = 0
 
+    def reset(self):
+        """Reset attachments, urls and input tokens"""
+        self.attachments = {}
+        self.urls = []
+        self.input_tokens = 0
+
     def get_attachments(self) -> Dict[str, str]:
         """
         Get attachments