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

pygpt_net/provider/api/google/chat.py

@@ -362,6 +362,12 @@ class Chat:
         except Exception:
             pass
 
+        # Download Files API file_data parts if present
+        try:
+            self._maybe_download_response_files(response, ctx)
+        except Exception:
+            pass
+
     def extract_text(self, response) -> str:
         """
         Extract output text.
@@ -792,7 +798,7 @@ class Chat:
                 return bytes(data)
             if isinstance(data, str):
                 import base64
-                return base64.b64decode(data)
+                return base64.b64encode(bytes()) if data == "" else base64.b64decode(data)
         except Exception:
             return None
         return None
@@ -1000,4 +1006,55 @@ class Chat:
                     out.append({"type": typ, "uri": uri})
                 continue
 
-        return out
+        return out
+
+    def _maybe_download_response_files(self, response, ctx: CtxItem) -> None:
+        """
+        Inspect non-stream response parts for Files API references and download them.
+        """
+        try:
+            cands = getattr(response, "candidates", None) or []
+            if not cands:
+                return
+            first = cands[0]
+            content = getattr(first, "content", None)
+            parts = getattr(content, "parts", None) or []
+        except Exception:
+            parts = []
+
+        if not parts:
+            return
+
+        downloaded: List[str] = []
+        for p in parts:
+            fdata = getattr(p, "file_data", None)
+            if not fdata:
+                continue
+            try:
+                uri = getattr(fdata, "file_uri", None) or getattr(fdata, "uri", None)
+                prefer = getattr(fdata, "file_name", None) or getattr(fdata, "display_name", None)
+                if not uri or not isinstance(uri, str):
+                    continue
+                # Only Gemini Files API refs are supported for direct download
+                save_path = self.window.core.api.google.store.download_to_dir(uri, prefer_name=prefer)
+                if save_path:
+                    downloaded.append(save_path)
+            except Exception:
+                continue
+
+        if downloaded:
+            downloaded = self.window.core.filesystem.make_local_list(downloaded)
+            if not isinstance(ctx.files, list):
+                ctx.files = []
+            for path in downloaded:
+                if path not in ctx.files:
+                    ctx.files.append(path)
+            images = []
+            for path in downloaded:
+                ext = os.path.splitext(path)[1].lower().lstrip(".")
+                if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                    images.append(path)
+            if images:
+                if not isinstance(ctx.images, list):
+                    ctx.images = []
+                ctx.images += images

pygpt_net/provider/api/google/realtime/client.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.31 23:00:00                  #
+# Updated Date: 2026.01.07 23:00:00                  #
 # ================================================== #
 
 import asyncio
@@ -338,20 +338,25 @@ class GoogleLiveClient:
         if sys_prompt:
             live_cfg["system_instruction"] = str(sys_prompt)
 
-        # Session resumption: enable updates; resume when a different non-empty handle is given
+        # Save callbacks and ctx early so handle persistence can target the current context
+        self._on_text = on_text
+        self._on_audio = on_audio
+        self._should_stop = should_stop or (lambda: False)
+        self._ctx = ctx
+        self._last_opts = opts
+
+        # Session resumption: configure per docs; include handle when provided, otherwise None.
         try:
+            ph = None
             provided_handle = getattr(opts, "rt_session_id", None)
-            resume_handle = None
             if isinstance(provided_handle, str):
-                ph = provided_handle.strip()
-                if ph and ph != (self._rt_session_id or ""):
-                    resume_handle = ph
+                ph = provided_handle.strip() or None
 
-            live_cfg["session_resumption"] = gtypes.SessionResumptionConfig(handle=resume_handle)
+            sr_cfg = gtypes.SessionResumptionConfig(handle=ph)
+            live_cfg["session_resumption"] = sr_cfg
 
-            if resume_handle:
-                self._rt_session_id = resume_handle
-                set_ctx_rt_handle(self._ctx, resume_handle, self.window)
+            if ph:
+                self._persist_rt_handle(ph)
         except Exception:
             pass
 
@@ -360,13 +365,6 @@ class GoogleLiveClient:
         apply_turn_mode_google(live_cfg, turn_mode)
         self._tune_google_vad(live_cfg, opts)
 
-        # Save callbacks and ctx
-        self._on_text = on_text
-        self._on_audio = on_audio
-        self._should_stop = should_stop or (lambda: False)
-        self._ctx = ctx
-        self._last_opts = opts
-
         # Control primitives
         self._response_done = asyncio.Event()
         self._send_lock = asyncio.Lock()
@@ -407,7 +405,7 @@ class GoogleLiveClient:
         self._rt_state = None
         self._last_tool_calls = []
 
-        # Clear only in-memory handle; keep persisted ctx.extra["rt_session_id"]
+        # Clear in-memory handle as well to prevent unintended resumption
         self._rt_session_id = None
 
         # Clear cached tools signature
@@ -820,11 +818,10 @@ class GoogleLiveClient:
                 try:
                     sru = getattr(response, "session_resumption_update", None) or getattr(response, "sessionResumptionUpdate", None)
                     if sru:
-                        resumable = bool(getattr(sru, "resumable", None))
-                        new_handle = getattr(sru, "new_handle", None) or getattr(sru, "newHandle", None)
-                        if resumable and isinstance(new_handle, str) and new_handle.strip():
-                            self._rt_session_id = new_handle.strip()
-                            set_ctx_rt_handle(self._ctx, self._rt_session_id, self.window)
+                        # Prefer robustness: persist handle if present, regardless of 'resumable' flag inconsistencies
+                        new_handle = self._extract_sru_handle(sru)
+                        if isinstance(new_handle, str) and new_handle.strip():
+                            self._persist_rt_handle(new_handle.strip())
                             if self.debug:
                                 print(f"[google.live] session handle updated: {self._rt_session_id}")
                 except Exception:
@@ -1740,6 +1737,10 @@ class GoogleLiveClient:
         """
         self.debug = bool(enabled)
 
+    def is_session(self) -> bool:
+        """Check if the WS session is currently open."""
+        return self._session is not None
+
     def is_session_active(self) -> bool:
         """Check if the WS session is currently open."""
         return self._session is not None
@@ -1748,6 +1749,12 @@ class GoogleLiveClient:
         """Update the current CtxItem (for session handle persistence)."""
         self._ctx = ctx
 
+    def get_current_rt_session_id(self) -> Optional[str]:
+        """
+        Return the current resumable session handle if known.
+        """
+        return self._rt_session_id
+
     # -----------------------------
     # Internal: auto-turn receiver bootstrap
     # -----------------------------
@@ -1942,4 +1949,43 @@ class GoogleLiveClient:
         """
         Emit RT_OUTPUT_AUDIO_COMMIT on first sign of model output in auto-turn mode.
         """
-        self._emit_audio_commit_signal()
+        self._emit_audio_commit_signal()
+
+    # -----------------------------
+    # Internal: session handle helpers
+    # -----------------------------
+
+    def _persist_rt_handle(self, handle: str) -> None:
+        """
+        Persist current session handle in-memory, to ctx.extra and into last opts for future restarts.
+        """
+        try:
+            self._rt_session_id = handle
+            set_ctx_rt_handle(self._ctx, handle, self.window)
+        except Exception:
+            pass
+        try:
+            if self._last_opts is not None:
+                setattr(self._last_opts, "rt_session_id", handle)
+        except Exception:
+            pass
+
+    def _extract_sru_handle(self, sru: Any) -> Optional[str]:
+        """
+        Extract handle from SessionResumptionUpdate (supports snake_case and camelCase, and token alias).
+        """
+        # Objects (attrs)
+        for attr in ("new_handle", "newHandle", "token"):
+            try:
+                v = getattr(sru, attr, None)
+                if isinstance(v, str) and v.strip():
+                    return v.strip()
+            except Exception:
+                pass
+        # Dicts
+        if isinstance(sru, dict):
+            for k in ("new_handle", "newHandle", "token"):
+                v = sru.get(k)
+                if isinstance(v, str) and v.strip():
+                    return v.strip()
+        return None

pygpt_net/provider/api/google/realtime/realtime.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.02 19:00:00                  #
+# Updated Date: 2026.01.07 23:00:00                  #
 # ================================================== #
 
 import json
@@ -86,8 +86,55 @@ class Realtime:
                     self.handler.send_tool_results_sync({
                         tool_call_id: tool_results
                     })
+                    self.handler.update_ctx(context.ctx)
                     return True  # do not start new session, just send tool results
 
+        # Tools
+        tools = self.window.core.api.google.tools.prepare(model, context.external_functions)
+        remote_tools = self.window.core.api.google.remote_tools.build_remote_tools(model)
+        if tools:
+            remote_tools = []  # in Google, remote tools are not allowed if function calling is used
+
+        # Resolve last session ID, prefer history, then fallback to current ctx and in-memory handler handle
+        last_session_id = extract_last_session_id(context.history) if context.history else None
+        if not last_session_id:
+            try:
+                if context.ctx and isinstance(context.ctx.extra, dict):
+                    sid = context.ctx.extra.get("rt_session_id")
+                    if isinstance(sid, str) and sid.strip():
+                        last_session_id = sid.strip()
+            except Exception:
+                pass
+        if not last_session_id and self.handler.is_session_active():
+            try:
+                sid = self.handler.get_current_rt_session_id()
+                if isinstance(sid, str) and sid.strip():
+                    last_session_id = sid.strip()
+            except Exception:
+                pass
+
+        if is_debug:
+            print("[realtime session] Last ID", last_session_id)
+
+        # Enforce clean state rules:
+        # - No history: always reset to ensure a fresh server context.
+        # - If history exists, keep the current live session even if the resumable handle has not been captured yet.
+        #   Gemini Live can emit the handle slightly after the first turn starts; closing here would drop context continuity.
+        try:
+            history_len = len(context.history) if context.history else 0
+        except Exception:
+            history_len = 0
+
+        if history_len == 0:
+            if self.handler.is_session_active():
+                self.handler.close_session_sync()
+            try:
+                if context.ctx and isinstance(context.ctx.extra, dict):
+                    context.ctx.extra.pop("rt_session_id", None)
+            except Exception:
+                pass
+            last_session_id = None  # force new session
+
         # update auto-turn in active session
         if (self.handler.is_session_active()
                 and (auto_turn != self.prev_auto_turn
@@ -95,23 +142,12 @@ class Realtime:
                      or opt_vad_prefix != self.prev_vad_prefix)):
             self.handler.update_session_autoturn_sync(auto_turn, opt_vad_silence, opt_vad_prefix)
 
-        # Tools
-        tools = self.window.core.api.google.tools.prepare(model, context.external_functions)
-        remote_tools = self.window.core.api.google.remote_tools.build_remote_tools(model)
-        if tools:
-            remote_tools = []  # in Google, remote tools are not allowed if function calling is used
-
         # if auto-turn is enabled and prompt is empty, update session and context only
         if auto_turn and self.handler.is_session_active() and (context.prompt.strip() == "" or context.prompt == "..."):
             self.handler.update_session_tools_sync(tools, remote_tools)
             self.handler.update_ctx(context.ctx)
             return True  # do not send new request if session is active
 
-        # Last session ID
-        last_session_id = extract_last_session_id(context.history)
-        if is_debug:
-            print("[realtime session] Last ID", last_session_id)
-
         # Voice
         voice_name = "Kore"
         try:

pygpt_net/provider/api/google/store.py

@@ -6,12 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.02 20:00:00                  #
+# Updated Date: 2026.01.06 06:00:00                  #
 # ================================================== #
 
 import os
 import time
-from typing import Optional, List, Dict, Any
+import mimetypes
+from typing import Optional, List, Dict, Any, Union
 
 from pygpt_net.item.store import RemoteStoreItem
 
@@ -63,6 +64,53 @@ class Store:
             v = hi
         return v
 
+    def _download_dir(self) -> str:
+        """
+        Resolve target download directory (uses download.dir if set).
+        """
+        if self.window.core.config.has("download.dir") and self.window.core.config.get("download.dir") != "":
+            dir_path = os.path.join(
+                self.window.core.config.get_user_dir('data'),
+                self.window.core.config.get("download.dir"),
+            )
+        else:
+            dir_path = self.window.core.config.get_user_dir('data')
+        os.makedirs(dir_path, exist_ok=True)
+        return dir_path
+
+    def _ensure_unique_path(self, dir_path: str, filename: str) -> str:
+        """
+        Ensure unique filename in dir, add timestamp prefix if exists.
+        """
+        path = os.path.join(dir_path, filename)
+        if os.path.exists(path):
+            prefix = time.strftime("%Y%m%d_%H%M%S_")
+            path = os.path.join(dir_path, f"{prefix}{filename}")
+        return path
+
+    def _guess_filename(self, file_meta: Any, fallback: str = "downloaded.bin") -> str:
+        """
+        Best-effort filename from File metadata or URI.
+        """
+        name = None
+        for attr in ("display_name", "filename", "name", "file_name"):
+            try:
+                val = getattr(file_meta, attr, None)
+                if not name and isinstance(val, str) and val:
+                    name = os.path.basename(val)
+            except Exception:
+                pass
+            if not name and isinstance(file_meta, dict):
+                val = file_meta.get(attr)
+                if isinstance(val, str) and val:
+                    name = os.path.basename(val)
+
+        if not name:
+            # allow URI-like strings
+            if isinstance(file_meta, str):
+                name = os.path.basename(file_meta.split("?")[0].split("#")[0])
+        return name or fallback
+
     # -----------------------------
     # Files service (global)
     # -----------------------------
@@ -105,6 +153,79 @@ class Store:
         if res is not None:
             return file_name
 
+    def download(self, file: Union[str, Any], path: str) -> bool:
+        """
+        Download a Files API item into the given path.
+
+        :param file: file name ('files/...'), file object, or file URI
+        :param path: target local path
+        :return: True on success
+        """
+        client = self.get_client()
+        data = None
+        try:
+            data = client.files.download(file=file)
+        except Exception:
+            pass
+        if not data:
+            return False
+        # google-genai returns bytes
+        try:
+            with open(path, "wb") as f:
+                f.write(data if isinstance(data, (bytes, bytearray)) else bytes(data))
+            return True
+        except Exception:
+            return False
+
+    def download_to_dir(self, file: Union[str, Any], prefer_name: Optional[str] = None) -> Optional[str]:
+        """
+        Download a Files API item into configured download directory.
+
+        :param file: file name ('files/...'), file object, or file URI
+        :param prefer_name: optional preferred filename
+        :return: saved path or None
+        """
+        dir_path = self._download_dir()
+        filename = None
+
+        # Try to resolve filename from metadata
+        file_meta = None
+        try:
+            name = None
+            if isinstance(file, str) and file.startswith("files/"):
+                name = file
+            elif hasattr(file, "name"):
+                name = getattr(file, "name", None)
+
+            if name:
+                file_meta = self.get_file(name)
+        except Exception:
+            file_meta = None
+
+        if prefer_name and isinstance(prefer_name, str):
+            filename = os.path.basename(prefer_name)
+
+        if not filename:
+            filename = self._guess_filename(file_meta if file_meta is not None else file)
+
+        # Infer extension from mime, if missing
+        if not os.path.splitext(filename)[1] and file_meta is not None:
+            try:
+                mime = getattr(file_meta, "mime_type", None)
+                if isinstance(file_meta, dict):
+                    mime = file_meta.get("mime_type", mime)
+                if mime:
+                    ext = mimetypes.guess_extension(mime) or ""
+                    if ext:
+                        filename = filename + ext
+            except Exception:
+                pass
+
+        path = self._ensure_unique_path(dir_path, filename)
+        if self.download(file, path):
+            return path
+        return None
+
     def get_files_ids_all(
             self,
             items: list,
@@ -377,7 +498,7 @@ class Store:
         for doc_name in files:
             self.log("Removing document from store [{}]:{} ".format(store_id, doc_name))
             self.delete_store_file(store_id, doc_name)
-            num += 1
+            num += 1        
         return num
 
     def remove_all(self, callback: Optional[callable] = None) -> int:

pygpt_net/provider/api/google/stream.py

@@ -93,6 +93,43 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
             except Exception:
                 pass
 
+    def _try_download_uri(uri: Optional[str], prefer_name: Optional[str] = None) -> Optional[str]:
+        """
+        Attempt to download a Files API URI via store; return local path or None.
+        """
+        if not isinstance(uri, str) or not uri:
+            return None
+        try:
+            path = core.api.google.store.download_to_dir(uri, prefer_name=prefer_name)
+            return path
+        except Exception:
+            return None
+
+    def _append_downloaded(paths):
+        if not paths:
+            return
+        try:
+            loc = core.filesystem.make_local_list(paths)
+        except Exception:
+            loc = paths
+        if not isinstance(ctx.files, list):
+            ctx.files = []
+        for p in loc:
+            if p not in ctx.files:
+                ctx.files.append(p)
+        # images
+        imgs = []
+        for p in loc:
+            ext = p.lower().rsplit(".", 1)[-1] if "." in p else ""
+            if ext in ["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]:
+                imgs.append(p)
+        if imgs:
+            if not isinstance(ctx.images, list):
+                ctx.images = []
+            for p in imgs:
+                if p not in ctx.images:
+                    ctx.images.append(p)
+
     # Collect function calls from Responses API style stream
     if fc_list:
         for fc in fc_list:
@@ -114,6 +151,23 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 content = getattr(cand, "content", None)
                 parts = getattr(content, "parts", None) or []
                 for p in parts:
+                    # Download Files API file_data parts if present
+                    try:
+                        fdata = getattr(p, "file_data", None)
+                        if fdata:
+                            uri = getattr(fdata, "file_uri", None) or getattr(fdata, "uri", None)
+                            name = getattr(fdata, "file_name", None) or getattr(fdata, "display_name", None)
+                            if uri and isinstance(uri, str):
+                                if not hasattr(state, "google_downloaded_uris"):
+                                    state.google_downloaded_uris = set()
+                                if uri not in state.google_downloaded_uris:
+                                    save = _try_download_uri(uri, name)
+                                    if save:
+                                        _append_downloaded([save])
+                                        state.google_downloaded_uris.add(uri)
+                    except Exception:
+                        pass
+
                     fn = getattr(p, "function_call", None)
                     if not fn:
                         continue
@@ -132,7 +186,6 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
             pass
 
     # Interactions API / Deep Research: collect streaming deltas and metadata
-    # Handles event_type, event_id, interaction.start/complete/status_update, and content.delta variants
     try:
         event_type = _get(chunk, "event_type", None)
         if event_type:
@@ -215,10 +268,8 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                     content_obj = _get(delta, "content", None)
                     thought_txt = None
                     if content_obj is not None:
-                        # TextContent path
                         thought_txt = _get(content_obj, "text", None)
                     if thought_txt is None:
-                        # Some SDKs expose 'thought' or 'content.text' differently
                         thought_txt = _get(delta, "thought", None)
                     if thought_txt:
                         _ensure_list_attr(state, "google_thought_summaries")
@@ -252,7 +303,6 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
 
                 # Function result delta (optional store)
                 elif delta_type == "function_result":
-                    # Can be used to log tool results; not altering UI text
                     _ensure_list_attr(state, "google_function_results")
                     try:
                         state.google_function_results.append(_to_plain_dict(delta))
@@ -269,7 +319,6 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                     else:
                         response_parts.append(str(code_txt))
                 elif delta_type == "code_execution_result":
-                    # Close code block; keep output logging internal if needed
                     if state.is_code:
                         response_parts.append("\n\n```\n-----------\n")
                         state.is_code = False
@@ -282,7 +331,7 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 # Images in stream
                 elif delta_type == "image":
                     # ImageDelta may contain base64 data or uri
-                    mime = (_get(delta, "mime_type", "") or "").lower()
+                    mime = _get(delta, "mime_type", None)
                     data_b64 = _get(delta, "data", None)
                     uri = _get(delta, "uri", None)
                     if data_b64:
@@ -299,12 +348,17 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                         except Exception:
                             pass
                     elif uri:
-                        try:
-                            if not hasattr(ctx, "urls") or ctx.urls is None:
-                                ctx.urls = []
-                            ctx.urls.append(uri)
-                        except Exception:
-                            pass
+                        # Try to download Files API content when URI is a file ref
+                        save = _try_download_uri(uri)
+                        if save:
+                            _append_downloaded([save])
+                        else:
+                            try:
+                                if not hasattr(ctx, "urls") or ctx.urls is None:
+                                    ctx.urls = []
+                                ctx.urls.append(uri)
+                            except Exception:
+                                pass
 
                 # URL context call/result (Deep Research tool)
                 elif delta_type == "url_context_call":
@@ -368,7 +422,6 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                     except Exception:
                         pass
 
-                # Thought signature delta (optional, store)
                 elif delta_type == "thought_signature":
                     _ensure_list_attr(state, "google_thought_signatures")
                     try:
@@ -380,12 +433,16 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 elif delta_type in ("audio", "video", "document"):
                     uri = _get(delta, "uri", None)
                     if uri:
-                        try:
-                            if not hasattr(ctx, "urls") or ctx.urls is None:
-                                ctx.urls = []
-                            ctx.urls.append(uri)
-                        except Exception:
-                            pass
+                        save = _try_download_uri(uri)
+                        if save:
+                            _append_downloaded([save])
+                        else:
+                            try:
+                                if not hasattr(ctx, "urls") or ctx.urls is None:
+                                    ctx.urls = []
+                                ctx.urls.append(uri)
+                            except Exception:
+                                pass
 
     except Exception:
         pass
@@ -459,11 +516,21 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 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)
+                    prefer = getattr(fdata, "file_name", None) or getattr(fdata, "display_name", None)
+                    if uri:
+                        if not hasattr(state, "google_downloaded_uris"):
+                            state.google_downloaded_uris = set()
+                        if uri not in state.google_downloaded_uris:
+                            save = _try_download_uri(uri, prefer)
+                            if save:
+                                _append_downloaded([save])
+                                state.google_downloaded_uris.add(uri)
+                        # keep original behavior for image http links
+                        mime = (getattr(fdata, "mime_type", "") or "").lower()
+                        if uri.startswith(("http://", "https://")) and mime.startswith("image/"):
+                            if ctx.urls is None:
+                                ctx.urls = []
+                            ctx.urls.append(uri)
 
         collect_google_citations(ctx, state, chunk)