pygpt-net 2.7.8__py3-none-any.whl → 2.7.10__py3-none-any.whl

pygpt_net/provider/api/google/image.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.31 16:00:00                  #
+# Updated Date: 2026.01.23 23:00:00                  #
 # ================================================== #
 
 import mimetypes
@@ -234,6 +234,13 @@ class ImageWorker(QRunnable):
                         reference_images=[raw_ref, mask_ref],
                         config=cfg,
                     )
+
+                    # record usage if provided
+                    try:
+                        self._record_usage_google(resp)
+                    except Exception:
+                        pass
+
                     imgs = getattr(resp, "generated_images", None) or []
                     for idx, gi in enumerate(imgs[: min(self.num, self.imagen_max_num)]):
                         data = self._extract_imagen_bytes(gi)
@@ -258,6 +265,13 @@ class ImageWorker(QRunnable):
                             image_config=img_cfg,
                         ),
                     )
+
+                    # record usage if provided
+                    try:
+                        self._record_usage_google(resp)
+                    except Exception:
+                        pass
+
                     saved = 0
                     for cand in getattr(resp, "candidates", []) or []:
                         parts = getattr(getattr(cand, "content", None), "parts", None) or []
@@ -291,6 +305,13 @@ class ImageWorker(QRunnable):
                 if self._using_vertex():
                     # Vertex Imagen edit API (preferred)
                     resp = self._imagen_edit(self.input_prompt, self.attachments, self.num)
+
+                    # record usage if provided
+                    try:
+                        self._record_usage_google(resp)
+                    except Exception:
+                        pass
+
                     imgs = getattr(resp, "generated_images", None) or []
                     for idx, gi in enumerate(imgs[: self.num]):
                         data = self._extract_imagen_bytes(gi)
@@ -303,6 +324,13 @@ class ImageWorker(QRunnable):
                 else:
                     # Gemini Developer API via Gemini image models (Nano Banana / Nano Banana Pro)
                     resp = self._gemini_edit(self.input_prompt, self.attachments, self.num)
+
+                    # record usage if provided
+                    try:
+                        self._record_usage_google(resp)
+                    except Exception:
+                        pass
+
                     saved = 0
                     for cand in getattr(resp, "candidates", []) or []:
                         parts = getattr(getattr(cand, "content", None), "parts", None) or []
@@ -326,6 +354,13 @@ class ImageWorker(QRunnable):
                 if self._is_imagen_generate(self.model) and self._using_vertex():
                     num = min(self.num, self.imagen_max_num)
                     resp = self._imagen_generate(self.input_prompt, num, self.resolution)
+
+                    # record usage if provided
+                    try:
+                        self._record_usage_google(resp)
+                    except Exception:
+                        pass
+
                     imgs = getattr(resp, "generated_images", None) or []
                     for idx, gi in enumerate(imgs[: num]):
                         data = self._extract_imagen_bytes(gi)
@@ -338,6 +373,13 @@ class ImageWorker(QRunnable):
                 else:
                     # Gemini Developer API image generation (Nano Banana / Nano Banana Pro) with robust sizing + optional reference images
                     resp = self._gemini_generate_image(self.input_prompt, self.model, self.resolution)
+
+                    # record usage if provided
+                    try:
+                        self._record_usage_google(resp)
+                    except Exception:
+                        pass
+
                     saved = 0
                     for cand in getattr(resp, "candidates", []) or []:
                         parts = getattr(getattr(cand, "content", None), "parts", None) or []
@@ -809,7 +851,7 @@ class ImageWorker(QRunnable):
         try:
             if not isinstance(self.ctx.extra, dict):
                 self.ctx.extra = {}
-            self.ctx.extra["image_id"] = str(value)
+            self.ctx.extra["image_id"] = self.window.core.filesystem.make_local(str(value))
             self.window.core.ctx.update_item(self.ctx)
         except Exception:
             pass
@@ -853,6 +895,51 @@ class ImageWorker(QRunnable):
         mime, _ = mimetypes.guess_type(uri)
         return mime or None
 
+    # ---------- usage helpers (Google GenAI) ----------
+
+    def _record_usage_google(self, response: Any) -> None:
+        """
+        Extract usage_metadata from Google GenAI response if present and store in ctx.
+        Saves to:
+          - ctx.set_tokens(prompt_token_count, candidates_token_count)
+          - ctx.extra["usage"] = {...}
+        """
+        try:
+            usage = getattr(response, "usage_metadata", None)
+            if not usage:
+                return
+
+            def _as_int(v) -> int:
+                try:
+                    return int(v)
+                except Exception:
+                    try:
+                        return int(float(v))
+                    except Exception:
+                        return 0
+
+            p = _as_int(getattr(usage, "prompt_token_count", 0) or 0)
+            c = _as_int(getattr(usage, "candidates_token_count", 0) or 0)
+            t = _as_int(getattr(usage, "total_token_count", (p + c)) or (p + c))
+
+            if self.ctx:
+                self.ctx.set_tokens(p, c)
+
+            if not isinstance(self.ctx.extra, dict):
+                self.ctx.extra = {}
+
+            self.ctx.extra["usage"] = {
+                "vendor": "google",
+                "model": str(self.model),
+                "input_tokens": p,
+                "output_tokens": c,
+                "total_tokens": t,
+                "source": "image",
+            }
+        except Exception:
+            # best-effort; ignore failures
+            pass
+
     def _cleanup(self):
         """Cleanup resources."""
         sig = self.signals

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/video.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.31 16:00:00                  #
+# Updated Date: 2026.01.23 23:00:00                  #
 # ================================================== #
 
 import base64, datetime, os, requests
@@ -480,7 +480,7 @@ class VideoWorker(QRunnable):
 
             if not isinstance(self.ctx.extra, dict):
                 self.ctx.extra = {}
-            self.ctx.extra["video_id"] = ref
+            self.ctx.extra["video_id"] = self.window.core.filesystem.make_local(ref)
             self.window.core.ctx.update_item(self.ctx)
         except Exception:
             pass

pygpt_net/provider/api/openai/__init__.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.21 13:00:00                  #
 # ================================================== #
 
 from openai import OpenAI
@@ -263,7 +263,30 @@ class ApiOpenAI:
 
         return True
 
-    def quick_call(self, context: BridgeContext, extra: dict = None) -> str:
+    def redirect_call(
+            self,
+            context: BridgeContext,
+            extra: dict = None
+    ) -> str:
+        """
+        Redirect quick call to standard call and return the output text
+
+        :param context: BridgeContext
+        :param extra: Extra parameters
+        :return: Output text
+        """
+        context.stream = False
+        context.mode = MODE_CHAT
+        self.locked = True
+        self.call(context, extra)
+        self.locked = False
+        return context.ctx.output
+
+    def quick_call(
+            self,
+            context: BridgeContext,
+            extra: dict = None
+    ) -> str:
         """
         Quick call OpenAI API with custom prompt
 
@@ -273,19 +296,13 @@ class ApiOpenAI:
         """
         # if normal request call then redirect
         if context.request:
-            context.stream = False
-            context.mode = "chat"  # fake mode for redirect
-            self.locked = True
-            self.call(context, extra)
-            self.locked = False
-            return context.ctx.output
+            return self.redirect_call(context, extra)
 
         self.locked = True
         ctx = context.ctx
         mode = context.mode
         prompt = context.prompt
         system_prompt = context.system_prompt
-        max_tokens = context.max_tokens
         temperature = context.temperature
         functions = context.external_functions
         history = context.history
@@ -309,8 +326,6 @@ class ApiOpenAI:
                 })
         messages.append({"role": "user", "content": prompt})
         additional_kwargs = {}
-        # if max_tokens > 0:
-        # additional_kwargs["max_tokens"] = max_tokens
 
         # tools / functions
         tools = self.window.core.api.openai.tools.prepare(model, functions)

pygpt_net/provider/api/openai/image.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2026.01.05 20:00:00                  #
+# Updated Date: 2026.01.23 23:00:00                  #
 # ================================================== #
 
 import base64
@@ -350,6 +350,12 @@ class ImageWorker(QRunnable):
                 self.signals.status.emit("API Error: empty response")
                 return
 
+            # record usage if provided by API
+            try:
+                self._record_usage_openai(response)
+            except Exception:
+                pass
+
             # download images
             for i in range(self.num):
                 if i >= len(response.data):
@@ -383,7 +389,7 @@ class ImageWorker(QRunnable):
                 try:
                     if not isinstance(self.ctx.extra, dict):
                         self.ctx.extra = {}
-                    self.ctx.extra["image_id"] = paths[0]
+                    self.ctx.extra["image_id"] = self.window.core.filesystem.make_local(paths[0])
                     self.window.core.ctx.update_item(self.ctx)
                 except Exception:
                     pass
@@ -430,4 +436,74 @@ class ImageWorker(QRunnable):
         neg = (negative or "").strip()
         if not neg:
             return base
-        return (base + ("\n" if base else "") + f"Negative prompt: {neg}").strip()
+        return (base + ("\n" if base else "") + f"Negative prompt: {neg}").strip()
+
+    # ---------- usage helpers (OpenAI Images API) ----------
+
+    def _record_usage_openai(self, response: Any) -> None:
+        """
+        Extract and store token usage from OpenAI Images API response if present.
+        Saves to:
+          - ctx.set_tokens(input_tokens, output_tokens)
+          - ctx.extra["usage"] = {...}
+        """
+        try:
+            usage = getattr(response, "usage", None)
+            if usage is None and isinstance(response, dict):
+                usage = response.get("usage")
+
+            if not usage:
+                return
+
+            def _as_int(v) -> int:
+                try:
+                    return int(v)
+                except Exception:
+                    try:
+                        return int(float(v))
+                    except Exception:
+                        return 0
+
+            # handle both attr and dict style
+            getv = lambda o, k: getattr(o, k, None) if not isinstance(o, dict) else o.get(k)
+
+            inp = _as_int(getv(usage, "input_tokens") or getv(usage, "prompt_tokens") or 0)
+            outp = _as_int(getv(usage, "output_tokens") or getv(usage, "completion_tokens") or 0)
+            total = _as_int(getv(usage, "total_tokens") or (inp + outp))
+
+            # store basic tokens
+            if self.ctx:
+                self.ctx.set_tokens(inp, outp)
+
+            # store detailed usage in ctx.extra["usage"]
+            if not isinstance(self.ctx.extra, dict):
+                self.ctx.extra = {}
+
+            # pass through details if available
+            input_details = getv(usage, "input_tokens_details") or getv(usage, "prompt_tokens_details") or {}
+            output_details = getv(usage, "output_tokens_details") or getv(usage, "completion_tokens_details") or {}
+
+            # normalize dict-like objects
+            def _to_plain(o):
+                try:
+                    if hasattr(o, "model_dump"):
+                        return o.model_dump()
+                    if hasattr(o, "to_dict"):
+                        return o.to_dict()
+                except Exception:
+                    pass
+                return o if isinstance(o, dict) else {}
+
+            self.ctx.extra["usage"] = {
+                "vendor": "openai",
+                "model": str(self.model),
+                "input_tokens": inp,
+                "output_tokens": outp,
+                "total_tokens": total,
+                "input_tokens_details": _to_plain(input_details),
+                "output_tokens_details": _to_plain(output_details),
+                "source": "images",
+            }
+        except Exception:
+            # do not raise, usage is best-effort
+            pass

pygpt_net/provider/api/openai/realtime/realtime.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.01 23:00:00                  #
+# Updated Date: 2026.01.07 23:00:00                  #
 # ================================================== #
 
 import json
@@ -102,6 +102,31 @@ class Realtime:
                     self.handler.update_ctx(context.ctx)
                     return True  # do not start new session, just send tool results
 
+        # Resolve last session ID from history only (do not fallback anywhere)
+        last_session_id = extract_last_session_id(context.history) if context.history else None
+        if is_debug:
+            print("[realtime session] Last ID", last_session_id)
+
+        # Enforce clean state rules before any live updates:
+        # - If there is no history at all: always reset live session to ensure a fresh context.
+        # - If there is history but it has no resumable session id: close any active session to avoid accidental continuation.
+        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
+        elif not last_session_id and self.handler.is_session_active():
+            self.handler.close_session_sync()
+
         # update auto-turn in active session
         if (self.handler.is_session_active()
                 and (auto_turn != self.prev_auto_turn
@@ -116,11 +141,6 @@ class Realtime:
             self.window.update_status(trans("speech.listening"))
             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 = "alloy"
         try: