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

pygpt_net/CHANGELOG.txt

@@ -1,3 +1,8 @@
+2.6.37 (2025-09-05)
+
+- Fixed: Function parameters sanitization in the Google Gen AI SDK.
+- Added: Native support for Anthropic SDK and xAI SDK (with remote tools).
+
 2.6.36 (2025-09-04)
 
 - Optimized rendering of large code blocks.

pygpt_net/__init__.py

@@ -6,15 +6,15 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.04 00:00:00                  #
+# Updated Date: 2025.09.05 00:00:00                  #
 # ================================================== #
 
 __author__ = "Marcin Szczygliński"
 __copyright__ = "Copyright 2025, Marcin Szczygliński"
 __credits__ = ["Marcin Szczygliński"]
 __license__ = "MIT"
-__version__ = "2.6.36"
-__build__ = "2025-09-04"
+__version__ = "2.6.37"
+__build__ = "2025-09-05"
 __maintainer__ = "Marcin Szczygliński"
 __github__ = "https://github.com/szczyglis-dev/py-gpt"
 __report__ = "https://github.com/szczyglis-dev/py-gpt/issues"

pygpt_net/controller/chat/handler/anthropic_stream.py

@@ -0,0 +1,166 @@
+#!/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 00:00:00                  #
+# ================================================== #
+
+import io
+from typing import Optional
+
+from .utils import as_int
+
+
+def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
+    """
+    Anthropic streaming events handler. Supports both full event objects and top-level delta objects.
+
+    :param ctx: Chat context
+    :param core: Core controller
+    :param state: Chat state
+    :param chunk: Incoming streaming chunk
+    :return: Extracted text delta or None
+    """
+    state.usage_vendor = "anthropic"
+    etype = str(getattr(chunk, "type", "") or "")
+    response: Optional[str] = None
+
+    # --- Top-level delta objects (when SDK yields deltas directly) ---
+    if etype == "text_delta":
+        txt = getattr(chunk, "text", None)
+        return str(txt) if txt is not None else None
+
+    if etype == "thinking_delta":
+        return None
+
+    if etype == "input_json_delta":
+        pj = getattr(chunk, "partial_json", "") or ""
+        buf = state.fn_args_buffers.get("__anthropic_last__")
+        if buf is None:
+            buf = io.StringIO()
+            state.fn_args_buffers["__anthropic_last__"] = buf
+        buf.write(pj)
+        if state.tool_calls:
+            state.tool_calls[-1]["function"]["arguments"] = buf.getvalue()
+        return None
+
+    if etype == "signature_delta":
+        return None
+
+    # --- Standard event flow ---
+    if etype == "message_start":
+        try:
+            msg = getattr(chunk, "message", None)
+            um = getattr(msg, "usage", None) if msg else None
+            if um:
+                inp = as_int(getattr(um, "input_tokens", None))
+                if inp is not None:
+                    state.usage_payload["in"] = inp
+        except Exception:
+            pass
+        return None
+
+    if etype == "content_block_start":
+        try:
+            cb = getattr(chunk, "content_block", None)
+            if cb and getattr(cb, "type", "") == "tool_use":
+                idx = getattr(chunk, "index", 0) or 0
+                tid = getattr(cb, "id", "") or ""
+                name = getattr(cb, "name", "") or ""
+                state.tool_calls.append({
+                    "id": tid,
+                    "type": "function",
+                    "function": {"name": name, "arguments": ""}
+                })
+                state.fn_args_buffers[str(idx)] = io.StringIO()
+                state.fn_args_buffers["__anthropic_last__"] = state.fn_args_buffers[str(idx)]
+        except Exception:
+            pass
+
+        try:
+            cb = getattr(chunk, "content_block", None)
+            if cb and getattr(cb, "type", "") == "web_search_tool_result":
+                results = getattr(cb, "content", None) or []
+                for r in results:
+                    url = r.get("url") if isinstance(r, dict) else None
+                    if url:
+                        if ctx.urls is None:
+                            ctx.urls = []
+                        if url not in ctx.urls:
+                            ctx.urls.append(url)
+        except Exception:
+            pass
+
+        return None
+
+    if etype == "content_block_delta":
+        try:
+            delta = getattr(chunk, "delta", None)
+            if not delta:
+                return None
+            if getattr(delta, "type", "") == "text_delta":
+                txt = getattr(delta, "text", None)
+                if txt is not None:
+                    response = str(txt)
+            elif getattr(delta, "type", "") == "input_json_delta":
+                idx = str(getattr(chunk, "index", 0) or 0)
+                buf = state.fn_args_buffers.get(idx)
+                pj = getattr(delta, "partial_json", "") or ""
+                if buf is None:
+                    buf = io.StringIO()
+                    state.fn_args_buffers[idx] = buf
+                buf.write(pj)
+                state.fn_args_buffers["__anthropic_last__"] = buf
+                try:
+                    if state.tool_calls:
+                        tc = state.tool_calls[-1]
+                        tc["function"]["arguments"] = buf.getvalue()
+                except Exception:
+                    pass
+        except Exception:
+            pass
+        return response
+
+    if etype == "content_block_stop":
+        try:
+            idx = str(getattr(chunk, "index", 0) or 0)
+            buf = state.fn_args_buffers.pop(idx, None)
+            if buf is not None:
+                try:
+                    args_val = buf.getvalue()
+                finally:
+                    try:
+                        buf.close()
+                    except Exception:
+                        pass
+                if state.tool_calls:
+                    state.tool_calls[-1]["function"]["arguments"] = args_val
+            if state.fn_args_buffers.get("__anthropic_last__") is buf:
+                state.fn_args_buffers.pop("__anthropic_last__", None)
+        except Exception:
+            pass
+        return None
+
+    if etype == "message_delta":
+        try:
+            usage = getattr(chunk, "usage", None)
+            if usage:
+                out_tok = as_int(getattr(usage, "output_tokens", None))
+                if out_tok is not None:
+                    state.usage_payload["out"] = out_tok
+            delta = getattr(chunk, "delta", None)
+            stop_reason = getattr(delta, "stop_reason", None) if delta else None
+            if stop_reason == "tool_use":
+                state.force_func_call = True
+        except Exception:
+            pass
+        return None
+
+    if etype == "message_stop":
+        return None
+
+    return None

pygpt_net/controller/chat/handler/google_stream.py

@@ -0,0 +1,181 @@
+#!/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 00:00:00                  #
+# ================================================== #
+
+import base64
+import json
+from typing import Optional, Any
+
+from .utils import capture_google_usage, collect_google_citations
+
+
+def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
+    """
+    Google python-genai streaming chunk.
+
+    :param ctx: Chat context
+    :param core: Core controller
+    :param state: Chat state
+    :param chunk: Incoming streaming chunk
+    :return: Extracted text delta or None
+    """
+    response_parts: list[str] = []
+
+    if state.google_stream_ref is None:
+        state.google_stream_ref = state.generator
+
+    try:
+        um = getattr(chunk, "usage_metadata", None)
+        if um:
+            capture_google_usage(state, um)
+    except Exception:
+        pass
+
+    try:
+        t = getattr(chunk, "text", None)
+        if t:
+            response_parts.append(t)
+    except Exception:
+        pass
+
+    fc_list = []
+    try:
+        fc_list = getattr(chunk, "function_calls", None) or []
+    except Exception:
+        fc_list = []
+
+    new_calls = []
+
+    def _to_plain_dict(obj: Any):
+        """Best-effort conversion of SDK objects to plain dict/list."""
+        try:
+            if hasattr(obj, "to_json_dict"):
+                return obj.to_json_dict()
+            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_dict(v) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [_to_plain_dict(x) for x in obj]
+        return obj
+
+    if fc_list:
+        for fc in fc_list:
+            name = getattr(fc, "name", "") or ""
+            args_obj = getattr(fc, "args", {}) or {}
+            args_dict = _to_plain_dict(args_obj) or {}
+            new_calls.append({
+                "id": getattr(fc, "id", "") or "",
+                "type": "function",
+                "function": {
+                    "name": name,
+                    "arguments": json.dumps(args_dict, ensure_ascii=False),
+                }
+            })
+    else:
+        try:
+            cands = getattr(chunk, "candidates", None) or []
+            for cand in cands:
+                content = getattr(cand, "content", None)
+                parts = getattr(content, "parts", None) or []
+                for p in parts:
+                    fn = getattr(p, "function_call", None)
+                    if not fn:
+                        continue
+                    name = getattr(fn, "name", "") or ""
+                    args_obj = getattr(fn, "args", {}) or {}
+                    args_dict = _to_plain_dict(args_obj) or {}
+                    new_calls.append({
+                        "id": getattr(fn, "id", "") or "",
+                        "type": "function",
+                        "function": {
+                            "name": name,
+                            "arguments": json.dumps(args_dict, ensure_ascii=False),
+                        }
+                    })
+        except Exception:
+            pass
+
+    if new_calls:
+        seen = {(tc["function"]["name"], tc["function"]["arguments"]) for tc in state.tool_calls}
+        for tc in new_calls:
+            key = (tc["function"]["name"], tc["function"]["arguments"])
+            if key not in seen:
+                state.tool_calls.append(tc)
+                seen.add(key)
+
+    try:
+        cands = getattr(chunk, "candidates", None) or []
+        for cand in cands:
+            content = getattr(cand, "content", None)
+            parts = getattr(content, "parts", None) or []
+
+            for p in parts:
+                ex = getattr(p, "executable_code", None)
+                if ex:
+                    lang = (getattr(ex, "language", None) or "python").strip() or "python"
+                    code_txt = (
+                        getattr(ex, "code", None) or
+                        getattr(ex, "program", None) or
+                        getattr(ex, "source", None) or
+                        ""
+                    )
+                    if code_txt is None:
+                        code_txt = ""
+                    if not state.is_code:
+                        response_parts.append(f"\n\n**Code interpreter**\n```{lang.lower()}\n{code_txt}")
+                        state.is_code = True
+                    else:
+                        response_parts.append(str(code_txt))
+
+                cer = getattr(p, "code_execution_result", None)
+                if cer:
+                    if state.is_code:
+                        response_parts.append("\n\n```\n-----------\n")
+                        state.is_code = False
+
+                blob = getattr(p, "inline_data", None)
+                if blob:
+                    mime = (getattr(blob, "mime_type", "") or "").lower()
+                    if mime.startswith("image/"):
+                        data = getattr(blob, "data", None)
+                        if data:
+                            if isinstance(data, (bytes, bytearray)):
+                                img_bytes = bytes(data)
+                            else:
+                                img_bytes = base64.b64decode(data)
+                            save_path = core.image.gen_unique_path(ctx)
+                            with open(save_path, "wb") as f:
+                                f.write(img_bytes)
+                            if not isinstance(ctx.images, list):
+                                ctx.images = []
+                            ctx.images.append(save_path)
+                            state.image_paths.append(save_path)
+                            state.has_google_inline_image = True
+
+                fdata = getattr(p, "file_data", None)
+                if fdata:
+                    uri = getattr(fdata, "file_uri", None) or getattr(fdata, "uri", None)
+                    mime = (getattr(fdata, "mime_type", "") or "").lower()
+                    if uri and mime.startswith("image/") and (uri.startswith("http://") or uri.startswith("https://")):
+                        if ctx.urls is None:
+                            ctx.urls = []
+                        ctx.urls.append(uri)
+
+        collect_google_citations(ctx, state, chunk)
+
+    except Exception:
+        pass
+
+    return "".join(response_parts) if response_parts else None

pygpt_net/controller/chat/handler/langchain_stream.py

@@ -0,0 +1,24 @@
+#!/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 00:00:00                  #
+# ================================================== #
+
+from typing import Optional
+
+
+def process_langchain_chat(chunk) -> Optional[str]:
+    """
+    LangChain chat streaming delta.
+
+    :param chunk: Incoming streaming chunk
+    :return: Extracted text delta or None
+    """
+    if getattr(chunk, "content", None) is not None:
+        return str(chunk.content)
+    return None

pygpt_net/controller/chat/handler/llamaindex_stream.py

@@ -0,0 +1,47 @@
+#!/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 00:00:00                  #
+# ================================================== #
+
+from typing import Optional
+
+
+def process_llama_chat(state, chunk) -> Optional[str]:
+    """
+    Llama chat streaming delta with optional tool call extraction.
+
+    :param state: Chat state
+    :param chunk: Incoming streaming chunk
+    :return: Extracted text delta or None
+    """
+    response = None
+    if getattr(chunk, "delta", None) is not None:
+        response = str(chunk.delta)
+
+    tool_chunks = getattr(getattr(chunk, "message", None), "additional_kwargs", {}).get("tool_calls", [])
+    if tool_chunks:
+        for tool_chunk in tool_chunks:
+            id_val = getattr(tool_chunk, "call_id", None) or getattr(tool_chunk, "id", None)
+            name = getattr(tool_chunk, "name", None) or getattr(getattr(tool_chunk, "function", None), "name", None)
+            args = getattr(tool_chunk, "arguments", None)
+            if args is None:
+                f = getattr(tool_chunk, "function", None)
+                args = getattr(f, "arguments", None) if f else None
+            if id_val:
+                if not args:
+                    args = "{}"
+                tool_call = {
+                    "id": id_val,
+                    "type": "function",
+                    "function": {"name": name, "arguments": args}
+                }
+                state.tool_calls.clear()
+                state.tool_calls.append(tool_call)
+
+    return response