pygpt-net 2.7.4__py3-none-any.whl → 2.7.5__py3-none-any.whl

pygpt_net/controller/assistant/editor.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 23:00:00                  #
+# Updated Date: 2026.01.02 20:00:00                  #
 # ================================================== #
 
 import copy
@@ -115,9 +115,9 @@ class Editor:
         current_id = self.get_selected_store_id()
         if current_id is not None:
             current_idx = self.get_choice_idx_by_id(current_id)
-        stores = self.window.core.assistants.store.get_all()
+        stores = self.window.core.remote_store.openai.get_all()
         for id in list(stores.keys()):
-            if self.window.core.assistants.store.is_hidden(id):
+            if self.window.core.remote_store.openai.is_hidden(id):
                 continue
             if stores[id].name is None or stores[id].name == "":
                 items[id] = id
@@ -158,10 +158,10 @@ class Editor:
         :param store_id: store ID
         :return: combo idx
         """
-        stores = self.window.core.assistants.store.get_all()
+        stores = self.window.core.remote_store.openai.get_all()
         i = 1
         for id in list(stores.keys()):
-            if self.window.core.assistants.store.is_hidden(id):
+            if self.window.core.remote_store.openai.is_hidden(id):
                 continue  # ignore empty names
             if id == store_id:
                 return i

pygpt_net/controller/assistant/files.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.27 00:00:00                  #
+# Updated Date: 2026.01.02 19:00:00                  #
 # ================================================== #
 
 import os
@@ -31,7 +31,7 @@ class Files:
     def update(self):
         """Update assistants files list"""
         self.update_list()
-        self.window.controller.assistant.store.update_files_list()
+        self.window.controller.remote_store.openai.update_files_list()
 
     def select(self, idx: int):
         """
@@ -48,7 +48,7 @@ class Files:
 
         # get file by list index
         thread_id = self.window.core.config.get('assistant_thread')
-        file_id = self.window.core.assistants.files.get_file_id_by_idx(idx, assistant.vector_store, thread_id)
+        file_id = self.window.core.remote_store.openai.files.get_file_id_by_idx(idx, assistant.vector_store, thread_id)
         self.window.core.assistants.current_file = file_id
 
     def count_upload(
@@ -96,7 +96,7 @@ class Files:
 
         ids = idx if isinstance(idx, list) else [idx]
         for idx in ids:
-            file_id = self.window.core.assistants.files.get_file_id_by_idx(idx, assistant.vector_store, thread_id)
+            file_id = self.window.core.remote_store.openai.files.get_file_id_by_idx(idx, assistant.vector_store, thread_id)
             self.window.controller.attachment.download(file_id)  # download file
 
     def rename(self, idx: int):
@@ -115,7 +115,7 @@ class Files:
         thread_id = self.window.core.config.get('assistant_thread')
 
         # get file by list index
-        file = self.window.core.assistants.files.get_file_by_idx(idx, assistant.vector_store, thread_id)
+        file = self.window.core.remote_store.openai.files.get_file_by_idx(idx, assistant.vector_store, thread_id)
         if file is None:
             return
 
@@ -139,7 +139,7 @@ class Files:
         :param record_id: file record ID
         :param name: new name
         """
-        self.window.core.assistants.files.rename(
+        self.window.core.remote_store.openai.files.rename(
             record_id,
             name,
         )
@@ -167,21 +167,21 @@ class Files:
         if self.window.core.assistants.has(id):
             assistant = self.window.core.assistants.get_by_id(id)
             thread_id = self.window.core.config.get('assistant_thread')
-            items = self.window.core.assistants.files.get_by_store_or_thread(assistant.vector_store, thread_id)
+            items = self.window.core.remote_store.openai.files.get_by_store_or_thread(assistant.vector_store, thread_id)
             self.window.update_status(trans('status.sending'))
             QApplication.processEvents()
 
             for id in list(items.keys()):
                 file = items[id]
                 try:
-                    self.window.core.assistants.files.delete(file)  # delete from DB, API and vector stores
+                    self.window.core.remote_store.openai.files.delete(file)  # delete from DB, API and vector stores
                 except Exception as e:
                     self.window.update_status(trans('status.error'))
                     self.window.ui.dialogs.alert(e)
 
             # update store status
             if assistant.vector_store:
-                self.window.controller.assistant.store.refresh_by_store_id(assistant.vector_store)
+                self.window.controller.remote_store.openai.refresh_by_store_id(assistant.vector_store)
 
             self.window.update_status(trans('status.deleted'))
 
@@ -215,7 +215,7 @@ class Files:
         # get files by list index
         ids = idx if isinstance(idx, list) else [idx]
         for idx in ids:
-            file = self.window.core.assistants.files.get_file_by_idx(idx, assistant.vector_store, thread_id)
+            file = self.window.core.remote_store.openai.files.get_file_by_idx(idx, assistant.vector_store, thread_id)
             if file is None:
                 continue
             files.append(file)
@@ -224,11 +224,11 @@ class Files:
         self.window.update_status(trans('status.sending'))
         QApplication.processEvents()
         try:
-            self.window.core.assistants.files.delete(files)  # delete from DB, API and vector stores
+            self.window.core.remote_store.openai.files.delete(files)  # delete from DB, API and vector stores
 
             # update store status
             if assistant.vector_store:
-                self.window.controller.assistant.store.refresh_by_store_id(assistant.vector_store)
+                self.window.controller.remote_store.openai.refresh_by_store_id(assistant.vector_store)
 
             self.window.update_status(trans('status.deleted'))
         except Exception as e:
@@ -312,7 +312,7 @@ class Files:
                         attachment,
                     )
 
-                    self.window.core.assistants.files.create(
+                    self.window.core.remote_store.openai.files.create(
                         assistant,
                         thread_id,
                         new_id,
@@ -341,7 +341,7 @@ class Files:
         if num > 0:
             # update store status
             if assistant.vector_store:
-                self.window.controller.assistant.store.refresh_by_store_id(assistant.vector_store)
+                self.window.controller.remote_store.openai.refresh_by_store_id(assistant.vector_store)
 
             self.update_list()  # update uploaded list UI
 
@@ -371,7 +371,7 @@ class Files:
         assistant = self.window.core.assistants.get_by_id(assistant_id)
         if assistant is None:
             return
-        items = self.window.core.assistants.files.get_by_store_or_thread(assistant.vector_store, thread_id)
+        items = self.window.core.remote_store.openai.files.get_by_store_or_thread(assistant.vector_store, thread_id)
         self.window.ui.chat.input.attachments_uploaded.update(items)
         self.update_tab()
 
@@ -385,7 +385,7 @@ class Files:
         assistant = self.window.core.assistants.get_by_id(assistant_id)
         if assistant is None:
             return  # no assistant
-        num_files = self.window.core.assistants.files.count_by_store_or_thread(assistant.vector_store, thread_id)
+        num_files = self.window.core.remote_store.openai.files.count_by_store_or_thread(assistant.vector_store, thread_id)
         suffix = ''
         # append num of files
         if num_files > 0:

pygpt_net/controller/chat/handler/google_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.03 02:10:00                  #
 # ================================================== #
 
 import base64
@@ -20,6 +20,10 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
     """
     Google python-genai streaming chunk.
 
+    Supports:
+    - Responses API streaming (generate_content)
+    - Interactions API streaming (including Deep Research agent and generic interactions)
+
     :param ctx: Chat context
     :param core: Core controller
     :param state: Chat state
@@ -70,6 +74,26 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
             return [_to_plain_dict(x) for x in obj]
         return obj
 
+    def _get(obj: Any, name: str, default: Any = None) -> Any:
+        """Safe getattr or dict get."""
+        try:
+            if hasattr(obj, name):
+                return getattr(obj, name)
+        except Exception:
+            pass
+        if isinstance(obj, dict):
+            return obj.get(name, default)
+        return default
+
+    def _ensure_list_attr(obj: Any, name: str):
+        """Ensure list attribute exists."""
+        if not hasattr(obj, name) or not isinstance(getattr(obj, name), list):
+            try:
+                setattr(obj, name, [])
+            except Exception:
+                pass
+
+    # Collect function calls from Responses API style stream
     if fc_list:
         for fc in fc_list:
             name = getattr(fc, "name", "") or ""
@@ -107,6 +131,273 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
         except Exception:
             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:
+            # Track last event id for reconnection
+            event_id = _get(chunk, "event_id", None)
+            if event_id:
+                try:
+                    state.google_last_event_id = event_id
+                except Exception:
+                    pass
+                try:
+                    if not hasattr(ctx, "extra") or ctx.extra is None:
+                        ctx.extra = {}
+                    ctx.extra["google_last_event_id"] = event_id
+                except Exception:
+                    pass
+
+            # Interaction lifecycle events
+            if event_type == "interaction.start":
+                interaction = _get(chunk, "interaction", None)
+                interaction_id = _get(interaction, "id", None)
+                if interaction_id:
+                    try:
+                        state.google_interaction_id = interaction_id
+                    except Exception:
+                        pass
+                    try:
+                        if not hasattr(ctx, "extra") or ctx.extra is None:
+                            ctx.extra = {}
+                        ctx.extra["google_interaction_id"] = interaction_id
+                    except Exception:
+                        pass
+
+            elif event_type == "interaction.status_update":
+                status = _get(chunk, "status", None)
+                if status:
+                    try:
+                        state.google_interaction_status = status
+                    except Exception:
+                        pass
+                    try:
+                        if not hasattr(ctx, "extra") or ctx.extra is None:
+                            ctx.extra = {}
+                        ctx.extra["google_interaction_status"] = status
+                    except Exception:
+                        pass
+
+            elif event_type == "interaction.complete":
+                # Capture usage from the final interaction if available
+                interaction = _get(chunk, "interaction", None)
+                usage = _get(interaction, "usage", None)
+                if usage:
+                    try:
+                        capture_google_usage(state, usage)
+                    except Exception:
+                        pass
+
+            elif event_type == "error":
+                err = _get(chunk, "error", {}) or {}
+                try:
+                    if not hasattr(ctx, "extra") or ctx.extra is None:
+                        ctx.extra = {}
+                    ctx.extra["google_interactions_error"] = _to_plain_dict(err)
+                except Exception:
+                    pass
+
+            # Content deltas
+            if event_type == "content.delta":
+                delta = _get(chunk, "delta", {}) or {}
+                delta_type = (_get(delta, "type", "") or "").lower()
+
+                # Text delta
+                if delta_type == "text":
+                    txt = _get(delta, "text", None)
+                    if txt:
+                        response_parts.append(txt)
+
+                # Thought summaries (Deep Research thinking summaries)
+                elif delta_type in ("thought", "thought_summary"):
+                    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")
+                        try:
+                            state.google_thought_summaries.append(thought_txt)
+                        except Exception:
+                            pass
+                        try:
+                            if not hasattr(ctx, "extra") or ctx.extra is None:
+                                ctx.extra = {}
+                            if "google_thought_summaries" not in ctx.extra or not isinstance(ctx.extra["google_thought_summaries"], list):
+                                ctx.extra["google_thought_summaries"] = []
+                            ctx.extra["google_thought_summaries"].append(thought_txt)
+                        except Exception:
+                            pass
+
+                # Function call delta (Interactions API tool/function calling)
+                elif delta_type == "function_call":
+                    fname = _get(delta, "name", "") or ""
+                    fargs_obj = _get(delta, "arguments", {}) or {}
+                    call_id = _get(delta, "id", "") or ""
+                    fargs_dict = _to_plain_dict(fargs_obj) or {}
+                    new_calls.append({
+                        "id": call_id,
+                        "type": "function",
+                        "function": {
+                            "name": fname,
+                            "arguments": json.dumps(fargs_dict, ensure_ascii=False),
+                        }
+                    })
+
+                # 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))
+                    except Exception:
+                        pass
+
+                # Code execution: code + result
+                elif delta_type == "code_execution_call":
+                    lang = (_get(delta, "language", None) or "python").strip() or "python"
+                    code_txt = _get(delta, "code", "") or ""
+                    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))
+                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
+                    _ensure_list_attr(state, "google_code_results")
+                    try:
+                        state.google_code_results.append(_to_plain_dict(delta))
+                    except Exception:
+                        pass
+
+                # Images in stream
+                elif delta_type == "image":
+                    # ImageDelta may contain base64 data or uri
+                    mime = (_get(delta, "mime_type", "") or "").lower()
+                    data_b64 = _get(delta, "data", None)
+                    uri = _get(delta, "uri", None)
+                    if data_b64:
+                        try:
+                            img_bytes = base64.b64decode(data_b64)
+                            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
+                        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
+
+                # URL context call/result (Deep Research tool)
+                elif delta_type == "url_context_call":
+                    urls = _get(delta, "urls", []) or []
+                    _ensure_list_attr(state, "google_url_context_calls")
+                    try:
+                        state.google_url_context_calls.append({"urls": list(urls)})
+                    except Exception:
+                        pass
+                elif delta_type == "url_context_result":
+                    url = _get(delta, "url", None)
+                    status = _get(delta, "status", None)
+                    _ensure_list_attr(state, "google_url_context_results")
+                    try:
+                        state.google_url_context_results.append({"url": url, "status": status, "raw": _to_plain_dict(delta)})
+                    except Exception:
+                        pass
+                    if url:
+                        try:
+                            if not hasattr(ctx, "urls") or ctx.urls is None:
+                                ctx.urls = []
+                            ctx.urls.append(url)
+                        except Exception:
+                            pass
+
+                # Google Search call/result (Deep Research tool)
+                elif delta_type == "google_search_call":
+                    queries = _get(delta, "queries", []) or []
+                    _ensure_list_attr(state, "google_research_queries")
+                    try:
+                        state.google_research_queries.extend(list(queries))
+                    except Exception:
+                        pass
+                elif delta_type == "google_search_result":
+                    url = _get(delta, "url", None)
+                    title = _get(delta, "title", None)
+                    rendered = _get(delta, "rendered_content", None)
+                    _ensure_list_attr(state, "google_search_results")
+                    try:
+                        state.google_search_results.append({
+                            "url": url,
+                            "title": title,
+                            "rendered_content": rendered,
+                            "raw": _to_plain_dict(delta),
+                        })
+                    except Exception:
+                        pass
+                    if url:
+                        try:
+                            if not hasattr(ctx, "urls") or ctx.urls is None:
+                                ctx.urls = []
+                            ctx.urls.append(url)
+                        except Exception:
+                            pass
+
+                # File search results (optional)
+                elif delta_type == "file_search_result":
+                    _ensure_list_attr(state, "google_file_search_results")
+                    try:
+                        state.google_file_search_results.append(_to_plain_dict(delta))
+                    except Exception:
+                        pass
+
+                # Thought signature delta (optional, store)
+                elif delta_type == "thought_signature":
+                    _ensure_list_attr(state, "google_thought_signatures")
+                    try:
+                        state.google_thought_signatures.append(_to_plain_dict(delta))
+                    except Exception:
+                        pass
+
+                # Other modalities: audio/video/document (store URIs if available)
+                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
+
+    except Exception:
+        pass
+
+    # Let Computer Use handler inspect chunk and tool calls (no-op if irrelevant)
+    new_calls, has_calls = core.api.google.computer.handle_stream_chunk(ctx, chunk, new_calls)
+    if has_calls:
+        ctx.extra["function_response_required"] = True  # required for automatic with-screenshot response
+        ctx.extra["function_response_source"] = "ctx.tool_calls"
+        ctx.extra["function_response_reason"] = "computer_use"
+        state.force_func_call = True
+
     if new_calls:
         seen = {(tc["function"]["name"], tc["function"]["arguments"]) for tc in state.tool_calls}
         for tc in new_calls:
@@ -115,6 +406,7 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
                 state.tool_calls.append(tc)
                 seen.add(key)
 
+    # Responses API-specific: parts parsing (code, images, file_data, etc.)
     try:
         cands = getattr(chunk, "candidates", None) or []
         for cand in cands:
@@ -178,4 +470,18 @@ def process_google_chunk(ctx, core, state, chunk) -> Optional[str]:
     except Exception:
         pass
 
+    # Interactions API citations: try to collect from delta.annotations if present
+    try:
+        if _get(chunk, "event_type", None) == "content.delta":
+            delta = _get(chunk, "delta", {}) or {}
+            annotations = _get(delta, "annotations", None)
+            if annotations:
+                _ensure_list_attr(state, "google_annotations")
+                try:
+                    state.google_annotations.extend(_to_plain_dict(annotations) or [])
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
     return "".join(response_parts) if response_parts else None

pygpt_net/controller/chat/handler/worker.py

@@ -62,6 +62,7 @@ class ChunkType(str, Enum):
     LANGCHAIN_CHAT = "langchain_chat"  # LangChain chat (deprecated)
     LLAMA_CHAT = "llama_chat"  # LlamaIndex chat
     GOOGLE = "google"  # Google SDK
+    GOOGLE_INTERACTIONS_API = "api_google_interactions"  # Google SDK, deep research - interactions
     ANTHROPIC = "anthropic"  # Anthropic SDK
     XAI_SDK = "xai_sdk"  # xAI SDK
     RAW = "raw"  # Raw string fallback
@@ -161,6 +162,12 @@ class StreamWorker(QRunnable):
                             state.chunk_type = ChunkType.API_CHAT_RESPONSES
                         else:
                             continue
+                    elif ctx.use_google_interactions_api:
+                        if hasattr(chunk, 'event_type'):
+                            etype = chunk.event_type  # type: ignore[assignment]
+                            state.chunk_type = ChunkType.GOOGLE_INTERACTIONS_API
+                        else:
+                            continue
                     else:
                         state.chunk_type = self._detect_chunk_type(chunk)
 
@@ -512,7 +519,7 @@ class StreamWorker(QRunnable):
             return self._process_langchain_chat(chunk)
         if t == ChunkType.LLAMA_CHAT:
             return self._process_llama_chat(state, chunk)
-        if t == ChunkType.GOOGLE:
+        if t == ChunkType.GOOGLE or t == ChunkType.GOOGLE_INTERACTIONS_API:
             return self._process_google_chunk(ctx, core, state, chunk)
         if t == ChunkType.ANTHROPIC:
             return self._process_anthropic_chunk(ctx, core, state, chunk)

pygpt_net/controller/chat/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.01 15:00:00                  #
 # ================================================== #
 
 import os
@@ -186,7 +186,7 @@ class Image:
                         f"![image]({ico_download})[**{trans('action.download')}**](bridge://download/{safe_path})")
             """
             urls.append(f"[**{trans('action.open')}**]({safe_path}) | "
-                        f"[**{trans('action.download')}**](bridge://download/{safe_path})")
+                        f"[**{trans('action.save_as')}**](bridge://download/{safe_path})")
             i += 1
         string += "\n".join(urls)