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

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/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

pygpt_net/provider/api/x_ai/__init__.py

@@ -0,0 +1,247 @@
+#!/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
+
+import os
+import json
+
+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
+
+import xai_sdk
+
+from .chat import Chat
+from .vision import Vision
+from .tools import Tools
+from .audio import Audio
+from .image import Image
+from .remote import Remote
+
+
+class ApiXAI:
+    def __init__(self, window=None):
+        """
+        xAI (Grok) Python SDK wrapper.
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.chat = Chat(window)
+        self.vision = Vision(window)
+        self.tools = Tools(window)
+        self.audio = Audio(window)
+        self.image = Image(window)
+        self.remote = Remote(window)  # Live Search builder
+        self.client: Optional[xai_sdk.Client] = None
+        self.locked = False
+        self.last_client_args: Optional[Dict[str, Any]] = None
+
+    def get_client(
+            self,
+            mode: str = MODE_CHAT,
+            model: ModelItem = None
+    ) -> xai_sdk.Client:
+        """
+        Get or create xAI client.
+
+        - Reads api_key from config or XAI_API_KEY env.
+        - Caches the client instance.
+
+        :param mode: One of MODE_*
+        :param model: ModelItem (optional, not used currently)
+        :return: xai_sdk.Client
+        """
+        if self.client is not None:
+            return self.client
+
+        cfg = self.window.core.config
+        api_key = cfg.get("api_key_xai") or os.environ.get("XAI_API_KEY") or ""
+        timeout = cfg.get("api_native_xai.timeout")  # optional
+
+        kwargs: Dict[str, Any] = {}
+        if api_key:
+            kwargs["api_key"] = api_key
+        if timeout is not None:
+            # Official SDK supports setting a global timeout on client init.
+            kwargs["timeout"] = timeout
+
+        self.client = xai_sdk.Client(**kwargs)
+        return self.client
+
+    def call(
+            self,
+            context: BridgeContext,
+            extra: dict = None,
+            rt_signals=None
+    ) -> bool:
+        """
+        Make an API call to xAI.
+
+        Supports chat (stream/non-stream), images (via REST),
+        and function-calling. Audio is not available in public xAI SDK at this time.
+
+        :param context: BridgeContext
+        :param extra: Extra params (not used)
+        :param rt_signals: Realtime signals (not used)
+        :return: True on success, False on error
+        """
+        mode = context.mode
+        model = context.model
+        stream = context.stream
+        ctx = context.ctx
+        ai_name = (ctx.output_name if ctx else "assistant")
+
+        # No Responses API in xAI SDK
+        if ctx:
+            ctx.use_responses_api = False
+
+        used_tokens = 0
+        response = None
+
+        if mode in (MODE_COMPLETION, MODE_CHAT, MODE_AUDIO, MODE_RESEARCH):
+            # There is no public realtime audio in SDK; treat MODE_AUDIO as chat (TTS not supported).
+            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:
+            # Image generation via REST /v1/images/generations (OpenAI-compatible)
+            return self.image.generate(context=context, extra=extra)
+
+        elif mode == MODE_ASSISTANT:
+            return False  # not implemented for xAI
+
+        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(context.mode, response, ctx)
+            try:
+                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:
+        """
+        Quick non-streaming xAI chat call and return output text.
+
+        If context.request is set, makes a full call() instead (for consistency).
+
+        :param context: BridgeContext
+        :param extra: Extra params (not used)
+        :return: Output text or "" on error
+        """
+        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()
+
+            tools = self.tools.prepare(functions)
+
+            # If tools are present, prefer non-streaming HTTP Chat Completions path to extract tool calls reliably.
+            # Otherwise use native SDK chat.sample().
+            if tools:
+                out, calls, citations, usage  = self.chat.call_http_nonstream(
+                    model=model.id,
+                    prompt=prompt,
+                    system_prompt=system_prompt,
+                    history=history,
+                    attachments=context.attachments,
+                    multimodal_ctx=context.multimodal_ctx,
+                    tools=tools,
+                    temperature=temperature,
+                    max_tokens=context.max_tokens,
+                )
+                if ctx:
+                    if calls:
+                        ctx.tool_calls = calls
+                return out or ""
+
+            # Native SDK path (no tools)
+            client = self.get_client(MODE_CHAT, model)
+            messages = self.chat.build_messages(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                model=model,
+                history=history,
+                attachments=context.attachments,
+                multimodal_ctx=context.multimodal_ctx,
+            )
+            chat = client.chat.create(model=model.id, messages=messages)
+            resp = chat.sample()
+            return getattr(resp, "content", "") or ""
+        except Exception as e:
+            self.window.core.debug.log(e)
+            return ""
+        finally:
+            self.locked = False
+
+    def stop(self):
+        """On global event stop."""
+        pass
+
+    def close(self):
+        """Close xAI client."""
+        if self.locked:
+            return
+        self.client = None  # xai-sdk gRPC channels close on GC; explicit close not exposed.
+
+    def safe_close(self):
+        """Close client."""
+        if self.locked:
+            return
+        self.client = None

pygpt_net/provider/api/x_ai/audio.py

@@ -0,0 +1,32 @@
+#!/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 Tuple
+
+
+class Audio:
+    def __init__(self, window=None):
+        """
+        Audio helpers for xAI.
+
+        Note: As of now, the public xAI Python SDK does not expose TTS/STT or realtime audio APIs.
+        This class exists to keep provider surface compatible.
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    # Placeholders to keep interface parity
+    def build_part(self, multimodal_ctx) -> None:
+        return None
+
+    def extract_first_audio_part(self, response) -> Tuple[None, None]:
+        return None, None