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

pygpt_net/provider/api/anthropic/__init__.py

@@ -6,63 +6,224 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.28 09:00:00                  #
+# Updated Date: 2025.09.05 01:00:00                  #
 # ================================================== #
 
-from anthropic import Anthropic
+from typing import Optional, Dict, Any
 
+import anthropic
 from pygpt_net.core.types import (
+    MODE_ASSISTANT,
+    MODE_AUDIO,
     MODE_CHAT,
+    MODE_COMPLETION,
+    MODE_IMAGE,
+    MODE_RESEARCH,
 )
+from pygpt_net.core.bridge.context import BridgeContext
 from pygpt_net.item.model import ModelItem
 
-class ApiAnthropic:
+from .chat import Chat
+from .tools import Tools
+from .vision import Vision
+from .audio import Audio
+from .image import Image
+
 
+class ApiAnthropic:
     def __init__(self, window=None):
         """
-        Anthropic API wrapper core
+        Anthropic Messages API SDK wrapper
 
         :param window: Window instance
         """
         self.window = window
-        self.client = None
+        self.chat = Chat(window)
+        self.tools = Tools(window)
+        self.vision = Vision(window)
+        self.audio = Audio(window)   # stub helpers (no official audio out/in in SDK as of now)
+        self.image = Image(window)   # stub: no image generation in Anthropic
+        self.client: Optional[anthropic.Anthropic] = None
         self.locked = False
+        self.last_client_args: Optional[Dict[str, Any]] = None
 
     def get_client(
             self,
             mode: str = MODE_CHAT,
-            model: ModelItem = None
-    ) -> Anthropic:
+            model: ModelItem = None,
+    ) -> anthropic.Anthropic:
+        """
+        Get or create Anthropic client
+
+        :param mode: Mode (chat, completion, image, etc.)
+        :param model: ModelItem
+        :return: anthropic.Anthropic instance
         """
-        Return Anthropic client
+        # Build minimal args from app config
+        args = self.window.core.models.prepare_client_args(mode, model)
+        filtered = {}
+        if args.get("api_key"):
+            filtered["api_key"] = args["api_key"]
+
+        # Optionally honor custom base_url if present in config (advanced)
+        # base_url = self.window.core.config.get("api_native_anthropic.base_url", "").strip()
+        # if base_url:
+            # filtered["base_url"] = base_url
+
+        # Keep a fresh client per call; Anthropic client is lightweight
+        return anthropic.Anthropic(**filtered)
 
-        :param mode: Mode
-        :param model: Model
-        :return: Anthropic client
+    def call(
+            self,
+            context: BridgeContext,
+            extra: dict = None,
+            rt_signals=None,   # unused for Anthropic
+    ) -> bool:
         """
-        if self.client is not None:
+        Make an API call to Anthropic Messages API
+
+        :param context: BridgeContext
+        :param extra: Extra parameters
+        :param rt_signals: Not used (no realtime Voice API)
+        :return: True if successful, False otherwise
+        """
+        mode = context.mode
+        model = context.model
+        stream = context.stream
+        ctx = context.ctx
+        ai_name = ctx.output_name if ctx else "assistant"
+
+        # Anthropic: no Responses API; stream events are custom to Anthropic
+        if ctx:
+            ctx.use_responses_api = False
+
+        used_tokens = 0
+        response = None
+
+        if mode in (MODE_COMPLETION, MODE_CHAT, MODE_AUDIO, MODE_RESEARCH):
+            # MODE_AUDIO fallback: treat as normal chat (no native audio API)
+            response = self.chat.send(context=context, extra=extra)
+            used_tokens = self.chat.get_used_tokens()
+            if ctx:
+                self.vision.append_images(ctx)
+
+        elif mode == MODE_IMAGE:
+            # Anthropic does not support image generation – only vision (image input in chat)
+            return self.image.generate(context=context, extra=extra)  # always returns False
+
+        elif mode == MODE_ASSISTANT:
+            return False  # not implemented for Anthropic
+
+        if stream:
+            if ctx:
+                ctx.stream = response
+                ctx.set_output("", ai_name)
+                ctx.input_tokens = used_tokens
+            return True
+
+        if response is None:
+            return False
+
+        if isinstance(response, dict) and "error" in response:
+            return False
+
+        if ctx:
+            ctx.ai_name = ai_name
+            self.chat.unpack_response(mode, response, ctx)
             try:
-                self.client.close()  # close previous client if exists
-            except Exception as e:
-                self.window.core.debug.log(e)
-                print("Error closing previous Anthropic client:", e)
-        self.client = Anthropic(
-            api_key=self.window.core.config.get('api_key_anthropic', "")
-        )
-        return self.client
+                import json
+                for tc in getattr(ctx, "tool_calls", []) or []:
+                    fn = tc.get("function") or {}
+                    args = fn.get("arguments")
+                    if isinstance(args, str):
+                        try:
+                            fn["arguments"] = json.loads(args)
+                        except Exception:
+                            fn["arguments"] = {}
+            except Exception:
+                pass
+        return True
+
+    def quick_call(
+            self,
+            context: BridgeContext,
+            extra: dict = None
+    ) -> str:
+        """
+        Make a quick API call to Anthropic and return the output text
+
+        :param context: BridgeContext
+        :param extra: Extra parameters
+        :return: Output text
+        """
+        if context.request:
+            context.stream = False
+            context.mode = MODE_CHAT
+            self.locked = True
+            self.call(context, extra)
+            self.locked = False
+            return context.ctx.output
+
+        self.locked = True
+        try:
+            ctx = context.ctx
+            prompt = context.prompt
+            system_prompt = context.system_prompt
+            temperature = context.temperature
+            history = context.history
+            functions = context.external_functions
+            model = context.model or self.window.core.models.from_defaults()
+
+            client = self.get_client(MODE_CHAT, model)
+            tools = self.tools.get_all_tools(model, functions)
+
+            inputs = self.chat.build_input(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                model=model,
+                history=history,
+                attachments=context.attachments,
+                multimodal_ctx=context.multimodal_ctx,
+            )
+
+            # Anthropic params
+            params: Dict[str, Any] = {
+                "model": model.id,
+                "max_tokens": context.max_tokens if context.max_tokens else 1024,
+                "messages": inputs,
+            }
+            if system_prompt:
+                params["system"] = system_prompt
+            if temperature is not None:
+                params["temperature"] = temperature
+            if tools:  # only include when non-empty list
+                params["tools"] = tools
+
+            resp = client.messages.create(**params)
+
+            if ctx:
+                calls = self.chat.extract_tool_calls(resp)
+                if calls:
+                    ctx.tool_calls = calls
+            return self.chat.extract_text(resp)
+        except Exception as e:
+            self.window.core.debug.log(e)
+            return ""
+        finally:
+            self.locked = False
 
     def stop(self):
-        """On global event stop"""
+        """On global event stop (no-op for Anthropic)"""
         pass
 
     def close(self):
-        """Close Anthropic client"""
+        """Close client (no persistent resources to close)"""
         if self.locked:
             return
-        if self.client is not None:
-            try:
-                pass
-                # self.client.close()
-            except Exception as e:
-                self.window.core.debug.log(e)
-                print("Error closing Anthropic client:", e)
+        self.client = None
+
+    def safe_close(self):
+        """Close client (safe)"""
+        if self.locked:
+            return
+        self.client = None

pygpt_net/provider/api/anthropic/audio.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: 2025.09.05 01:00:00                  #
+# ================================================== #
+
+from typing import Optional
+from pygpt_net.core.bridge.context import MultimodalContext
+
+
+class Audio:
+    def __init__(self, window=None):
+        """
+        Audio helpers for Anthropic (currently no official input/output audio in Python SDK).
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    def build_input_block(self, multimodal_ctx: Optional[MultimodalContext]) -> Optional[dict]:
+        """
+        Future hook: build input_audio block if Anthropic exposes it publicly.
+        Currently returns None to avoid 400 errors.
+        """
+        return None

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