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

pygpt_net/provider/api/anthropic/chat.py

@@ -0,0 +1,341 @@
+#!/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                  #
+# ================================================== #
+
+from typing import Optional, Dict, Any, List
+
+from pygpt_net.core.types import MODE_CHAT, MODE_AUDIO
+from pygpt_net.core.bridge.context import BridgeContext, MultimodalContext
+from pygpt_net.item.attachment import AttachmentItem
+from pygpt_net.item.ctx import CtxItem
+from pygpt_net.item.model import ModelItem
+
+import anthropic
+from anthropic.types import Message
+
+
+class Chat:
+    def __init__(self, window=None):
+        """
+        Anthropic chat / multimodal API wrapper.
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.input_tokens = 0
+
+    def send(self, context: BridgeContext, extra: Optional[Dict[str, Any]] = None):
+        """
+        Call Anthropic Messages API for chat / multimodal.
+
+        :param context: BridgeContext
+        :param extra: Extra parameters (not used)
+        :return: Message or generator of Message (if streaming)
+        """
+        prompt = context.prompt
+        stream = context.stream
+        system_prompt = context.system_prompt
+        model = context.model
+        functions = context.external_functions
+        attachments = context.attachments
+        multimodal_ctx = context.multimodal_ctx
+        mode = context.mode
+        ctx = context.ctx or CtxItem()
+        api = self.window.core.api.anthropic
+        client: anthropic.Anthropic = api.get_client(context.mode, model)
+
+        msgs = self.build_input(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            model=model,
+            history=context.history,
+            attachments=attachments,
+            multimodal_ctx=multimodal_ctx,
+        )
+
+        self.reset_tokens()
+        count_msgs = self._build_count_messages(prompt, system_prompt, model, context.history)
+        self.input_tokens += self.window.core.tokens.from_messages(count_msgs, model.id)
+
+        tools = api.tools.get_all_tools(model, functions)
+        max_tokens = context.max_tokens if context.max_tokens else 1024
+        temperature = self.window.core.config.get('temperature')
+        top_p = self.window.core.config.get('top_p')
+
+        params: Dict[str, Any] = {
+            "model": model.id,
+            "messages": msgs,
+            "max_tokens": max_tokens,
+        }
+        # Add optional fields only if provided
+        if system_prompt:
+            params["system"] = system_prompt  # SDK expects string or blocks, not None
+        if temperature is not None:
+            params["temperature"] = temperature  # keep as-is; upstream config controls the type
+        if top_p is not None:
+            params["top_p"] = top_p
+        if tools:  # only include when non-empty list
+            params["tools"] = tools  # must be a valid list per API
+
+        if mode == MODE_AUDIO:
+            stream = False  # no native TTS
+
+        if stream:
+            return client.messages.create(stream=True, **params)
+        else:
+            return client.messages.create(**params)
+
+    def unpack_response(self, mode: str, response: Message, ctx: CtxItem):
+        """
+        Unpack non-streaming response and set context.
+
+        :param mode: Mode (chat/audio)
+        :param response: Message response from API
+        :param ctx: CtxItem to update
+        """
+        ctx.output = self.extract_text(response)
+
+        calls = self.extract_tool_calls(response)
+        if calls:
+            ctx.tool_calls = calls
+
+        # Usage
+        try:
+            usage = getattr(response, "usage", None)
+            if usage:
+                p = getattr(usage, "input_tokens", 0) or 0
+                c = getattr(usage, "output_tokens", 0) or 0
+                ctx.set_tokens(p, c)
+                if not isinstance(ctx.extra, dict):
+                    ctx.extra = {}
+                ctx.extra["usage"] = {"vendor": "anthropic", "input_tokens": p, "output_tokens": c}
+        except Exception:
+            pass
+
+        # Collect web search citations (web_search_tool_result blocks)
+        try:
+            self._collect_web_search_urls(response, ctx)
+        except Exception:
+            pass
+
+    def extract_text(self, response: Message) -> str:
+        """
+        Extract text from response content blocks.
+
+        Join all text blocks into a single string.
+
+        :param response: Message response from API
+        :return: Extracted text
+        """
+        out: List[str] = []
+        try:
+            for blk in getattr(response, "content", []) or []:
+                if getattr(blk, "type", "") == "text" and getattr(blk, "text", None):
+                    out.append(str(blk.text))
+        except Exception:
+            pass
+        return "".join(out).strip()
+
+    def extract_tool_calls(self, response: Message) -> List[dict]:
+        """
+        Extract tool_use blocks as app tool calls.
+
+        Each tool call is a dict with keys: id (str), type="function", function (dict with name and arguments).
+
+        :param response: Message response from API
+        :return: List of tool calls
+        """
+        out: List[dict] = []
+
+        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
+
+        try:
+            for blk in getattr(response, "content", []) or []:
+                if getattr(blk, "type", "") == "tool_use":
+                    out.append({
+                        "id": getattr(blk, "id", "") or "",
+                        "type": "function",
+                        "function": {
+                            "name": getattr(blk, "name", "") or "",
+                            "arguments": to_plain(getattr(blk, "input", {}) or {}),
+                        }
+                    })
+        except Exception:
+            pass
+        return out
+
+    def _collect_web_search_urls(self, response: Message, ctx: CtxItem):
+        """
+        Collect URLs from web_search_tool_result blocks and attach to ctx.urls.
+
+        :param response: Message response from API
+        :param ctx: CtxItem to update
+        """
+        urls: List[str] = []
+        try:
+            for blk in getattr(response, "content", []) or []:
+                if getattr(blk, "type", "") == "web_search_tool_result":
+                    content = getattr(blk, "content", None) or []
+                    for item in content:
+                        if isinstance(item, dict) and item.get("type") == "web_search_result":
+                            u = (item.get("url") or "").strip()
+                            if u.startswith("http://") or u.startswith("https://"):
+                                urls.append(u)
+        except Exception:
+            pass
+
+        if urls:
+            if ctx.urls is None:
+                ctx.urls = []
+            for u in urls:
+                if u not in ctx.urls:
+                    ctx.urls.append(u)
+
+    def build_input(
+            self,
+            prompt: str,
+            system_prompt: str,
+            model: ModelItem,
+            history: Optional[List[CtxItem]] = None,
+            attachments: Optional[Dict[str, AttachmentItem]] = None,
+            multimodal_ctx: Optional[MultimodalContext] = None) -> List[dict]:
+        """
+        Build Anthropic messages list.
+
+        :param prompt: User prompt
+        :param system_prompt: System prompt
+        :param model: ModelItem
+        :param history: Optional list of CtxItem for context
+        :param attachments: Optional dict of attachments (id -> AttachmentItem)
+        :param multimodal_ctx: Optional MultimodalContext
+        :return: List of messages for API
+        """
+        messages: List[dict] = []
+
+        if self.window.core.config.get('use_context'):
+            items = self.window.core.ctx.get_history(
+                history,
+                model.id,
+                MODE_CHAT,
+                self.window.core.tokens.from_user(prompt, system_prompt),
+                self._fit_ctx(model),
+            )
+            for item in items:
+                if item.final_input:
+                    messages.append({"role": "user", "content": str(item.final_input)})
+                if item.final_output:
+                    messages.append({"role": "assistant", "content": str(item.final_output)})
+
+        parts = self._build_user_parts(
+            content=str(prompt or ""),
+            attachments=attachments,
+            multimodal_ctx=multimodal_ctx,
+        )
+        messages.append({"role": "user", "content": parts if parts else [{"type": "text", "text": str(prompt or "")}]})
+        return messages
+
+    def _build_user_parts(
+            self,
+            content: str,
+            attachments: Optional[Dict[str, AttachmentItem]] = None,
+            multimodal_ctx: Optional[MultimodalContext] = None) -> List[dict]:
+        """
+        Build user content blocks (image + text).
+
+        :param content: Text content
+        :param attachments: Optional dict of attachments (id -> AttachmentItem)
+        :param multimodal_ctx: Optional MultimodalContext
+        :return: List of content blocks
+        """
+        parts: List[dict] = []
+        self.window.core.api.anthropic.vision.reset()
+        if attachments:
+            img_parts = self.window.core.api.anthropic.vision.build_blocks(content, attachments)
+            parts.extend(img_parts)
+        if content:
+            parts.append({"type": "text", "text": str(content)})
+
+        # No input_audio supported in SDK at the time of writing
+        if multimodal_ctx and getattr(multimodal_ctx, "is_audio_input", False):
+            pass
+
+        return parts
+
+    def _fit_ctx(self, model: ModelItem) -> int:
+        """
+        Fit context length to model limits.
+
+        :param model: ModelItem
+        :return: Max context tokens
+        """
+        max_ctx_tokens = self.window.core.config.get('max_total_tokens')
+        if model and model.ctx and 0 < model.ctx < max_ctx_tokens:
+            max_ctx_tokens = model.ctx
+        return max_ctx_tokens
+
+    def _build_count_messages(
+            self,
+            prompt: str,
+            system_prompt: str,
+            model: ModelItem,
+            history: Optional[List[CtxItem]] = None) -> List[dict]:
+        """
+        Build messages for token counting (without attachments).
+
+        :param prompt: User prompt
+        :param system_prompt: System prompt
+        :param model: ModelItem
+        :param history: Optional list of CtxItem for context
+        :return: List of messages for token counting
+        """
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        if self.window.core.config.get('use_context'):
+            used_tokens = self.window.core.tokens.from_user(prompt, system_prompt)
+            items = self.window.core.ctx.get_history(
+                history,
+                model.id,
+                MODE_CHAT,
+                used_tokens,
+                self._fit_ctx(model),
+            )
+            for item in items:
+                if item.final_input:
+                    messages.append({"role": "user", "content": str(item.final_input)})
+                if item.final_output:
+                    messages.append({"role": "assistant", "content": str(item.final_output)})
+
+        messages.append({"role": "user", "content": str(prompt or "")})
+        return messages
+
+    def reset_tokens(self):
+        """Reset input tokens counter."""
+        self.input_tokens = 0
+
+    def get_used_tokens(self) -> int:
+        """
+        Get used input tokens count.
+
+        :return: used input tokens
+        """
+        return self.input_tokens

pygpt_net/provider/api/anthropic/image.py

@@ -0,0 +1,25 @@
+#!/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                  #
+# ================================================== #
+
+from typing import Optional, Dict
+from pygpt_net.core.bridge.context import BridgeContext
+
+
+class Image:
+    def __init__(self, window=None):
+        self.window = window
+
+    def generate(self, context: BridgeContext, extra: Optional[Dict] = None, sync: bool = True) -> bool:
+        """
+        Anthropic does not support image generation; only vision input.
+        """
+        # Inform handlers that nothing was generated
+        return False

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("sonnet-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)