pygpt-net 2.7.4__py3-none-any.whl → 2.7.6__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

@@ -6,20 +6,19 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.07 05:00:00                  #
+# Updated Date: 2026.01.03 17:00:00                  #
 # ================================================== #
 
 import io
 import json
 from dataclasses import dataclass, field
 from typing import Optional, Literal, Any
-from enum import Enum
 
 from PySide6.QtCore import QObject, Signal, Slot, QRunnable
 from openai.types.chat import ChatCompletionChunk
 
 from pygpt_net.core.events import RenderEvent
-from pygpt_net.core.text.utils import has_unclosed_code_tag
+from pygpt_net.core.types.chunk import ChunkType
 from pygpt_net.item.ctx import CtxItem
 
 from . import (
@@ -52,21 +51,6 @@ EventType = Literal[
 ]
 
 
-class ChunkType(str, Enum):
-    """
-    Enum for chunk type classification.
-    """
-    API_CHAT = "api_chat"  # OpenAI Chat Completions / or compatible
-    API_CHAT_RESPONSES = "api_chat_responses"  # OpenAI Responses
-    API_COMPLETION = "api_completion"  # OpenAI Completions
-    LANGCHAIN_CHAT = "langchain_chat"  # LangChain chat (deprecated)
-    LLAMA_CHAT = "llama_chat"  # LlamaIndex chat
-    GOOGLE = "google"  # Google SDK
-    ANTHROPIC = "anthropic"  # Anthropic SDK
-    XAI_SDK = "xai_sdk"  # xAI SDK
-    RAW = "raw"  # Raw string fallback
-
-
 class WorkerSignals(QObject):
     """
     Defines the signals available from a running worker thread.
@@ -154,13 +138,13 @@ class StreamWorker(QRunnable):
 
                     etype: Optional[EventType] = None
 
-                    # detect chunk type
-                    if ctx.use_responses_api:
+                    # detect chunk type if not defined
+                    if ctx.chunk_type:
+                        state.chunk_type = ctx.chunk_type
                         if hasattr(chunk, 'type'):
-                            etype = chunk.type  # type: ignore[assignment]
-                            state.chunk_type = ChunkType.API_CHAT_RESPONSES
-                        else:
-                            continue
+                            etype = chunk.type
+                        elif hasattr(chunk, 'event_type'):
+                            etype = chunk.event_type
                     else:
                         state.chunk_type = self._detect_chunk_type(chunk)
 
@@ -512,7 +496,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)
@@ -542,6 +526,7 @@ class StreamWorker(QRunnable):
         return anthropic_stream.process_anthropic_chunk(ctx, core, state, chunk)
 
     def _process_xai_sdk_chunk(self, ctx, core, state, item):
+        print(item)
         return xai_stream.process_xai_sdk_chunk(ctx, core, state, item)
 
     def _process_raw(self, chunk) -> Optional[str]: