pygpt-net 2.7.6__py3-none-any.whl → 2.7.7__py3-none-any.whl

pygpt_net/provider/api/anthropic/remote_tools.py

@@ -0,0 +1,172 @@
+#!/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: 2026.01.05 20:00:00                  #
+# ================================================== #
+
+import json
+from typing import List, Any, Dict, Optional
+
+from pygpt_net.item.model import ModelItem
+
+class RemoteTools:
+    def __init__(self, window=None):
+        """
+        Remote tools mapper for Anthropic Messages API.
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    def build_remote_tools(self, model: ModelItem = None) -> List[dict]:
+        """
+        Build Anthropic server tools (remote tools) based on config flags.
+        Supports: Web Search, Code Execution, Web Fetch, Tool Search, MCP toolset.
+
+        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] = []
+
+        # keep compatibility with previous models that had no remote tool support
+        if model and model.id and model.id.startswith("claude-3-5"):
+            # remote tool availability on 3.5 models varies; previous behavior was to skip
+            return tools
+
+        # Helper: bool from config with provider-specific fallback
+        def cfg_bool(*keys: str, default: bool = False) -> bool:
+            for k in keys:
+                v = cfg.get(k)
+                if isinstance(v, bool):
+                    return v
+            return default
+
+        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()]
+
+        # --- Web Search (server tool) ---
+        is_web = self.window.controller.chat.remote_tools.enabled(model, "web_search")
+        if is_web:
+            ttype = cfg.get("remote_tools.anthropic.web_search.type", "web_search_20250305")
+            tname = "web_search"
+            tool_def: Dict[str, Any] = {
+                "type": ttype,
+                "name": tname,
+            }
+            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
+            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
+            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,
+                }
+                tool_def["user_location"] = {k: v for k, v in tool_def["user_location"].items() if v is not None}
+            tools.append(tool_def)
+
+        # --- Code Execution (server tool) ---
+        is_code_exec = cfg_bool("remote_tools.anthropic.code_execution", default=False)
+        if is_code_exec:
+            tools.append({
+                "type": "code_execution_20250825",
+                "name": "code_execution",
+            })
+
+        # --- Web Fetch (server tool) ---
+        is_web_fetch = cfg_bool("remote_tools.anthropic.web_fetch", default=False)
+        if is_web_fetch:
+            fetch_def: Dict[str, Any] = {
+                "type": "web_fetch_20250910",
+                "name": "web_fetch",
+            }
+            max_uses = cfg.get("remote_tools.anthropic.web_fetch.max_uses")
+            if isinstance(max_uses, int) and max_uses > 0:
+                fetch_def["max_uses"] = max_uses
+            allowed = parse_csv_list("remote_tools.anthropic.web_fetch.allowed_domains")
+            blocked = parse_csv_list("remote_tools.anthropic.web_fetch.blocked_domains")
+            if allowed:
+                fetch_def["allowed_domains"] = allowed
+            elif blocked:
+                fetch_def["blocked_domains"] = blocked
+            citations_enabled = cfg_bool("remote_tools.anthropic.web_fetch.citations.enabled", default=True)
+            if citations_enabled:
+                fetch_def["citations"] = {"enabled": True}
+            max_content_tokens = cfg.get("remote_tools.anthropic.web_fetch.max_content_tokens")
+            if isinstance(max_content_tokens, int) and max_content_tokens > 0:
+                fetch_def["max_content_tokens"] = max_content_tokens
+            tools.append(fetch_def)
+
+        # --- Tool Search (server tool) ---
+        """
+        is_tool_search = cfg_bool("remote_tools.anthropic.tool_search", default=False)
+        if is_tool_search:
+            variant = (cfg.get("remote_tools.anthropic.tool_search.variant")
+                       or cfg.get("remote_tools.tool_search.variant") or "regex")
+            # accept full type as well
+            raw_type = str(cfg.get("remote_tools.anthropic.tool_search.type")
+                           or cfg.get("remote_tools.tool_search.type") or "").strip()
+            if raw_type.startswith("tool_search_tool_"):
+                ttype = raw_type
+                tname = "tool_search_tool_regex" if "regex" in raw_type else "tool_search_tool_bm25"
+            else:
+                if str(variant).lower() == "bm25":
+                    ttype = "tool_search_tool_bm25_20251119"
+                    tname = "tool_search_tool_bm25"
+                else:
+                    ttype = "tool_search_tool_regex_20251119"
+                    tname = "tool_search_tool_regex"
+            tools.append({
+                "type": ttype,
+                "name": tname,
+            })
+        """
+
+        # --- MCP toolset (server-side tool catalog from MCP servers) ---
+        is_mcp = cfg_bool("remote_tools.anthropic.mcp", default=False)
+        if is_mcp:
+            raw_tools = cfg.get("remote_tools.anthropic.mcp.tools")
+            if raw_tools:
+                try:
+                    if isinstance(raw_tools, (list, dict)):
+                        mcp_tools = raw_tools
+                    else:
+                        mcp_tools = json.loads(raw_tools)
+                    # ensure list
+                    if isinstance(mcp_tools, dict):
+                        mcp_tools = [mcp_tools]
+                    for t in mcp_tools:
+                        if isinstance(t, dict):
+                            # default type if not set
+                            if "type" not in t:
+                                t["type"] = "mcp_toolset"
+                            tools.append(t)
+                except Exception:
+                    pass  # ignore invalid JSON to avoid breaking existing flows
+
+        return tools

pygpt_net/{controller/chat/handler/anthropic_stream.py → provider/api/anthropic/stream.py}

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 00:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import io
@@ -28,6 +28,18 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
     state.usage_vendor = "anthropic"
     etype = str(getattr(chunk, "type", "") or "")
     response: Optional[str] = None
+    is_computer_call = False
+
+    # Computer Use: translate Anthropic 'computer' tool_use stream into plugin calls
+    try:
+        tool_calls, has_calls = core.api.anthropic.computer.handle_stream_chunk(ctx, chunk, state.tool_calls)
+        state.tool_calls = tool_calls
+        if has_calls:
+            is_computer_call = True
+            state.force_func_call = True
+    except Exception:
+        pass
+
 
     # --- Top-level delta objects (when SDK yields deltas directly) ---
     if etype == "text_delta":
@@ -37,7 +49,7 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
     if etype == "thinking_delta":
         return None
 
-    if etype == "input_json_delta":
+    if etype == "input_json_delta" and not is_computer_call:
         pj = getattr(chunk, "partial_json", "") or ""
         buf = state.fn_args_buffers.get("__anthropic_last__")
         if buf is None:
@@ -64,18 +76,20 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
             pass
         return None
 
-    if etype == "content_block_start":
+    if etype == "content_block_start" and not is_computer_call:
         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": ""}
-                })
+                # Skip generic function-call for Anthropic Computer Use; the adapter will emit computer_call items.
+                if name not in {"computer", "computer.use", "anthropic/computer", "computer_use", "computer-use"}:
+                    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:
@@ -97,7 +111,7 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
 
         return None
 
-    if etype == "content_block_delta":
+    if etype == "content_block_delta" and not is_computer_call:
         try:
             delta = getattr(chunk, "delta", None)
             if not delta:
@@ -125,7 +139,7 @@ def process_anthropic_chunk(ctx, core, state, chunk) -> Optional[str]:
             pass
         return response
 
-    if etype == "content_block_stop":
+    if etype == "content_block_stop" and not is_computer_call:
         try:
             idx = str(getattr(chunk, "index", 0) or 0)
             buf = state.fn_args_buffers.pop(idx, None)

pygpt_net/provider/api/anthropic/tools.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.17 05:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import json
@@ -152,78 +152,16 @@ class Tools:
                 if not params.get("type"):
                     params["type"] = "object"
 
-            tools.append({
+            # pass through tool as client tool
+            tool_def = {
                 "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
-
-        is_web = self.window.controller.chat.remote_tools.enabled(model, "web_search")  # get global config
-
-        # Web Search tool
-        if is_web:
-            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}
+            # optional: allow defer_loading for tool search when configured per-tool (kept compatible)
+            if isinstance(fn, dict) and fn.get("defer_loading") is True:
+                tool_def["defer_loading"] = True
 
             tools.append(tool_def)
 
@@ -231,28 +169,45 @@ class Tools:
 
     def merge_tools_dedup(self, primary: List[dict], secondary: List[dict]) -> List[dict]:
         """
-        Remove duplicate tools by name, preserving order:
+        Remove duplicate tools, preserving order:
 
         - First from primary list
-        - Then from secondary list if name not already present
+        - Then from secondary list if not already present
+
+        Dedup rules:
+          * Tools with a 'name' are deduped by name.
+          * MCP toolsets (type == 'mcp_toolset') are deduped by (type, mcp_server_name).
+          * Tools without a 'name' use (type) as a fallback key.
 
         :param primary: Primary list of tool dicts
         :param secondary: Secondary list of tool dicts
         :return: Merged list of tool dicts without duplicates
         """
+        def key_for(t: dict) -> str:
+            name = t.get("name")
+            if name:
+                return f"name::{name}"
+            ttype = t.get("type")
+            if ttype == "mcp_toolset":
+                return f"mcp::{t.get('mcp_server_name', '')}"
+            return f"type::{ttype}"
+
         result: List[dict] = []
         seen = set()
+
         for t in primary or []:
-            n = t.get("name")
-            if n and n not in seen:
-                seen.add(n)
+            k = key_for(t)
+            if k not in seen:
+                seen.add(k)
                 result.append(t)
+
         for t in secondary or []:
-            n = t.get("name")
-            if not n or n in seen:
+            k = key_for(t)
+            if k in seen:
                 continue
-            seen.add(n)
+            seen.add(k)
             result.append(t)
+
         return result
 
     def get_all_tools(self, model: ModelItem, functions: list) -> List[dict]:
@@ -264,5 +219,5 @@ class Tools:
         :return: Combined list of tool dicts
         """
         base_tools = self.prepare(model, functions)
-        remote_tools = self.build_remote_tools(model)
+        remote_tools = self.window.core.api.anthropic.remote_tools.build_remote_tools(model)
         return self.merge_tools_dedup(base_tools, remote_tools)

pygpt_net/provider/api/anthropic/utils.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: 2026.01.05 20:00:00                  #
+# ================================================== #
+
+from typing import Any, Optional
+
+
+def as_int(val: Any) -> Optional[int]:
+    """
+    Coerce to int if possible, else None.
+
+    :param val: Input value
+    :return: int or None
+    """
+    if val is None:
+        return None
+    try:
+        return int(val)
+    except Exception:
+        try:
+            return int(float(val))
+        except Exception:
+            return None

pygpt_net/provider/api/google/chat.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.03 17:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import os
@@ -121,12 +121,8 @@ class Chat:
 
         # Enable Computer Use tool in computer mode (use the official Tool/ComputerUse object)
         if mode == MODE_COMPUTER or (model and isinstance(model.id, str) and "computer-use" in model.id.lower()):
-            comp_env = gtypes.Environment.ENVIRONMENT_BROWSER
-            tools = [gtypes.Tool(
-                computer_use=gtypes.ComputerUse(
-                    environment=comp_env,
-                )
-            )]  # reset tools to only Computer Use (multiple tools not supported together)
+            tool = self.window.core.api.google.computer.get_tool()
+            tools = [tool]  # reset tools to only Computer Use (multiple tools not supported together)
 
         # Some models cannot use tools; keep behavior for image-only models
         if model and isinstance(model.id, str) and "-image" in model.id:

pygpt_net/{controller/chat/handler/google_stream.py → provider/api/google/stream.py}

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.03 02:10:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 import base64

pygpt_net/provider/api/google/utils.py

@@ -0,0 +1,185 @@
+#!/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: 2026.01.05 20:00:00                  #
+# ================================================== #
+
+from typing import Any, Optional
+
+
+def safe_get(obj: Any, path: str) -> Any:
+    """
+    Dot-path getter for dicts and objects.
+
+    :param obj: Source object or dict
+    :param path: Dot-separated path, e.g. 'a.b.0.c'
+    :return: Value at path or None
+    """
+    cur = obj
+    for seg in path.split("."):
+        if cur is None:
+            return None
+        if isinstance(cur, dict):
+            cur = cur.get(seg)
+        else:
+            if seg.isdigit() and isinstance(cur, (list, tuple)):
+                idx = int(seg)
+                if 0 <= idx < len(cur):
+                    cur = cur[idx]
+                else:
+                    return None
+            else:
+                cur = getattr(cur, seg, None)
+    return cur
+
+
+def as_int(val: Any) -> Optional[int]:
+    """
+    Coerce to int if possible, else None.
+
+    :param val: Input value
+    :return: int or None
+    """
+    if val is None:
+        return None
+    try:
+        return int(val)
+    except Exception:
+        try:
+            return int(float(val))
+        except Exception:
+            return None
+
+def capture_google_usage(state, um_obj: Any):
+    """
+    Extract usage for Google python-genai; prefer total - prompt to include reasoning.
+
+    :param state: Chat state
+    :param um_obj: Usage metadata object/dict
+    """
+    if not um_obj:
+        return
+    state.usage_vendor = "google"
+    prompt = (
+        as_int(safe_get(um_obj, "prompt_token_count")) or
+        as_int(safe_get(um_obj, "prompt_tokens")) or
+        as_int(safe_get(um_obj, "input_tokens"))
+    )
+    total = (
+        as_int(safe_get(um_obj, "total_token_count")) or
+        as_int(safe_get(um_obj, "total_tokens"))
+    )
+    candidates = (
+        as_int(safe_get(um_obj, "candidates_token_count")) or
+        as_int(safe_get(um_obj, "output_tokens"))
+    )
+    reasoning = (
+        as_int(safe_get(um_obj, "candidates_reasoning_token_count")) or
+        as_int(safe_get(um_obj, "reasoning_tokens")) or 0
+    )
+    if total is not None and prompt is not None:
+        out_total = max(0, total - prompt)
+    else:
+        out_total = candidates
+    state.usage_payload = {"in": prompt, "out": out_total, "reasoning": reasoning or 0, "total": total}
+
+
+def collect_google_citations(ctx, state, chunk: Any):
+    """
+    Collect web citations (URLs) from Google GenAI stream.
+
+    :param ctx: Chat context
+    :param state: Chat state
+    :param chunk: Incoming streaming chunk
+    """
+    try:
+        cands = getattr(chunk, "candidates", None) or []
+    except Exception:
+        cands = []
+
+    if not isinstance(state.citations, list):
+        state.citations = []
+
+    def _add_url(url: Optional[str]):
+        if not url or not isinstance(url, str):
+            return
+        url = url.strip()
+        if not (url.startswith("http://") or url.startswith("https://")):
+            return
+        if ctx.urls is None:
+            ctx.urls = []
+        if url not in state.citations:
+            state.citations.append(url)
+        if url not in ctx.urls:
+            ctx.urls.append(url)
+
+    for cand in cands:
+        gm = safe_get(cand, "grounding_metadata") or safe_get(cand, "groundingMetadata")
+        if gm:
+            atts = safe_get(gm, "grounding_attributions") or safe_get(gm, "groundingAttributions") or []
+            try:
+                for att in atts or []:
+                    for path in (
+                        "web.uri",
+                        "web.url",
+                        "source.web.uri",
+                        "source.web.url",
+                        "source.uri",
+                        "source.url",
+                        "uri",
+                        "url",
+                    ):
+                        _add_url(safe_get(att, path))
+            except Exception:
+                pass
+            for path in (
+                "search_entry_point.uri",
+                "search_entry_point.url",
+                "searchEntryPoint.uri",
+                "searchEntryPoint.url",
+                "search_entry_point.rendered_content_uri",
+                "searchEntryPoint.rendered_content_uri",
+            ):
+                _add_url(safe_get(gm, path))
+
+        cm = safe_get(cand, "citation_metadata") or safe_get(cand, "citationMetadata")
+        if cm:
+            cit_arrays = (
+                safe_get(cm, "citation_sources") or
+                safe_get(cm, "citationSources") or
+                safe_get(cm, "citations") or []
+            )
+            try:
+                for cit in cit_arrays or []:
+                    for path in ("uri", "url", "source.uri", "source.url", "web.uri", "web.url"):
+                        _add_url(safe_get(cit, path))
+            except Exception:
+                pass
+
+        try:
+            parts = safe_get(cand, "content.parts") or []
+            for p in parts:
+                pcm = safe_get(p, "citation_metadata") or safe_get(p, "citationMetadata")
+                if pcm:
+                    arr = (
+                        safe_get(pcm, "citation_sources") or
+                        safe_get(pcm, "citationSources") or
+                        safe_get(pcm, "citations") or []
+                    )
+                    for cit in arr or []:
+                        for path in ("uri", "url", "source.uri", "source.url", "web.uri", "web.url"):
+                            _add_url(safe_get(cit, path))
+                gpa = safe_get(p, "grounding_attributions") or safe_get(p, "groundingAttributions") or []
+                for att in gpa or []:
+                    for path in ("web.uri", "web.url", "source.web.uri", "source.web.url", "uri", "url"):
+                        _add_url(safe_get(att, path))
+        except Exception:
+            pass
+
+    if state.citations and (ctx.urls is None or not ctx.urls):
+        ctx.urls = list(state.citations)

pygpt_net/{controller/chat/handler/langchain_stream.py → provider/api/langchain/stream.py}

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 00:00:00                  #
+# Updated Date: 2026.01.05 20:00:00                  #
 # ================================================== #
 
 from typing import Optional