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

pygpt_net/provider/api/google/worker/importer.py

@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2026.01.02 20:00:00                  #
+# ================================================== #
+
+import os
+
+from PySide6.QtCore import QObject, Signal, QRunnable, Slot
+
+
+class Importer(QObject):
+    def __init__(self, window=None):
+        """
+        Importer core (Google File Search)
+
+        :param window: Window instance
+        """
+        super(Importer, self).__init__()
+        self.window = window
+        self.worker = None
+
+    @Slot(str, object)
+    def handle_error(self, mode: str, err: any):
+        """
+        Handle thread error signal
+
+        :param mode: mode
+        :param err: error message
+        """
+        if mode == "import_files":
+            self.window.controller.remote_store.google.batch.handle_imported_files_failed(err)
+        elif mode == "truncate_files":
+            self.window.controller.remote_store.google.batch.handle_truncated_files_failed(err)
+        elif mode == "upload_files":
+            self.window.controller.remote_store.google.batch.handle_uploaded_files_failed(err)
+        elif mode in "vector_stores":
+            self.window.controller.remote_store.google.batch.handle_imported_stores_failed(err)
+        elif mode in "truncate_vector_stores":
+            self.window.controller.remote_store.google.batch.handle_truncated_stores_failed(err)
+        elif mode in "refresh_vector_stores":
+            self.window.controller.remote_store.google.batch.handle_refreshed_stores_failed(err)
+
+    @Slot(str, str, int)
+    def handle_finished(self, mode: str, store_id: str = None, num: int = 0):
+        """
+        Handle thread finished signal
+
+        :param mode: mode
+        :param store_id: store ID
+        :param num: number of affected items
+        """
+        if mode == "import_files":
+            self.window.controller.remote_store.google.batch.handle_imported_files(num)
+        elif mode == "truncate_files":
+            self.window.controller.remote_store.google.batch.handle_truncated_files(store_id, num)
+        elif mode == "upload_files":
+            self.window.controller.remote_store.google.batch.handle_uploaded_files(num)
+        elif mode == "vector_stores":
+            self.window.controller.remote_store.google.batch.handle_imported_stores(num)
+        elif mode == "truncate_vector_stores":
+            self.window.controller.remote_store.google.batch.handle_truncated_stores(num)
+        elif mode == "refresh_vector_stores":
+            self.window.controller.remote_store.google.batch.handle_refreshed_stores(num)
+
+    @Slot(str, str)
+    def handle_status(self, mode: str, msg: str):
+        """
+        Handle thread status change signal
+
+        :param mode: mode
+        :param msg: message
+        """
+        self.window.controller.assistant.batch.handle_status_change(mode, msg)
+
+    @Slot(str, str)
+    def handle_log(self, mode: str, msg: str):
+        """
+        Handle thread log message signal
+
+        :param mode: mode
+        :param msg: message
+        """
+        self.window.controller.assistant.threads.log(mode + ": " + msg)
+
+    def import_assistants(self):
+        """Import assistants (kept for parity; no-op for Google if unused)"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "assistants"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def import_vector_stores(self):
+        """Import File Search stores"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def truncate_vector_stores(self):
+        """Truncate File Search stores"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "truncate_vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def truncate_files(self, store_id: str = None):
+        """
+        Truncate documents
+
+        :param store_id: store name ('fileSearchStores/...').
+        """
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "truncate_files"
+        self.worker.store_id = store_id
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def upload_files(self, store_id: str, files: list = None):
+        """
+        Upload files
+
+        :param store_id: store name ('fileSearchStores/...').
+        :param files: list of file paths
+        """
+        print("Uploading files: {}".format(files))
+        print("Store ID: {}".format(store_id))
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "upload_files"
+        self.worker.store_id = store_id
+        self.worker.files = files or []
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def refresh_vector_stores(self):
+        """Refresh File Search stores"""
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "refresh_vector_stores"
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def import_files(self, store_id: str = None):
+        """
+        Import File Search documents
+
+        :param store_id: store name ('fileSearchStores/...').
+        """
+        self.worker = ImportWorker()
+        self.worker.window = self.window
+        self.worker.mode = "import_files"
+        self.worker.store_id = store_id
+        self.connect_signals(self.worker)
+        self.window.threadpool.start(self.worker)
+
+    def connect_signals(self, worker):
+        """
+        Connect signals
+
+        :param worker: worker instance
+        """
+        worker.signals.finished.connect(self.handle_finished)
+        worker.signals.error.connect(self.handle_error)
+        worker.signals.status.connect(self.handle_status)
+        worker.signals.log.connect(self.handle_log)
+
+
+class ImportWorkerSignals(QObject):
+    """Import worker signals"""
+    status = Signal(str, str)            # mode, message
+    finished = Signal(str, str, int)     # mode, store_id, num
+    error = Signal(str, object)          # mode, error
+    log = Signal(str, str)               # mode, message
+
+
+class ImportWorker(QRunnable):
+    """Import worker (Google)"""
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.signals = ImportWorkerSignals()
+        self.window = None
+        self.mode = "assistants"
+        self.assistant = None
+        self.store_id = None
+        self.files = []
+
+    @Slot()
+    def run(self):
+        """Importer thread"""
+        try:
+            if self.mode == "vector_stores":
+                if self.import_vector_stores():
+                    self.import_files()
+            elif self.mode == "truncate_vector_stores":
+                self.truncate_vector_stores()
+            elif self.mode == "refresh_vector_stores":
+                self.refresh_vector_stores()
+            elif self.mode == "truncate_files":
+                self.truncate_files()
+            elif self.mode == "import_files":
+                self.import_files()
+            elif self.mode == "upload_files":
+                self.upload_files()
+        except Exception as e:
+            self.signals.error.emit(self.mode, e)
+        finally:
+            self.cleanup()
+
+    def import_assistants(self, silent: bool = False) -> bool:
+        """
+        Import assistants (not used for Google by default; kept for parity)
+
+        :param silent: silent mode
+        """
+        try:
+            if not silent:
+                self.signals.finished.emit("assistants", self.store_id, 0)
+            return True
+        except Exception as e:
+            self.signals.error.emit("assistants", e)
+            return False
+
+    def import_vector_stores(self, silent: bool = False) -> bool:
+        """
+        Import File Search stores
+
+        :param silent: silent mode (no signals emit)
+        """
+        try:
+            self.log("Importing File Search stores...")
+            self.window.core.remote_store.google.clear()
+            items = {}
+            self.window.core.api.google.store.import_stores(items, callback=self.callback)
+            self.window.core.remote_store.google.import_items(items)
+            if not silent:
+                self.signals.finished.emit("vector_stores", self.store_id, len(items))
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("vector_stores", e)
+            return False
+
+    def truncate_vector_stores(self, silent: bool = False) -> bool:
+        """
+        Truncate all File Search stores in API
+
+        :param silent: silent mode
+        """
+        try:
+            self.log("Truncating stores...")
+            num = self.window.core.api.google.store.remove_all(callback=self.callback)
+            self.window.core.remote_store.google.items = {}
+            self.window.core.remote_store.google.save()
+            if not silent:
+                self.signals.finished.emit("truncate_vector_stores", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("truncate_vector_stores", e)
+            return False
+
+    def refresh_vector_stores(self, silent: bool = False) -> bool:
+        """
+        Refresh all File Search stores in API
+
+        :param silent: silent mode
+        """
+        try:
+            self.log("Refreshing stores...")
+            num = 0
+            stores = self.window.core.remote_store.google.items
+            for id in stores:
+                store = stores[id]
+                try:
+                    self.window.controller.remote_store.google.refresh_store(store, update=False)
+                    num += 1
+                except Exception as e:
+                    self.log("Failed to refresh store: {}".format(id))
+                    self.window.core.debug.log(e)
+            if not silent:
+                self.signals.finished.emit("refresh_vector_stores", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("refresh_vector_stores", e)
+            return False
+
+    def truncate_files(self, silent: bool = False) -> bool:
+        """
+        Truncate documents in API
+
+        :param silent: silent mode
+        """
+        try:
+            if self.store_id is None:
+                self.log("Truncating all documents in all stores...")
+                self.window.core.remote_store.google.files.truncate()  # clear all locally and remote
+                num = self.window.core.api.google.store.remove_from_stores()
+            else:
+                self.log("Truncating documents for store: {}".format(self.store_id))
+                self.window.core.remote_store.google.files.truncate(self.store_id)
+                num = self.window.core.api.google.store.remove_from_store(self.store_id)
+            if not silent:
+                self.signals.finished.emit("truncate_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("truncate_files", e)
+            return False
+
+    def upload_files(self, silent: bool = False) -> bool:
+        """
+        Upload files directly to a File Search store (creates Documents)
+
+        :param silent: silent mode
+        """
+        num = 0
+        try:
+            self.log("Uploading files to File Search store...")
+            for file in self.files:
+                try:
+                    doc = self.window.core.api.google.store.upload_to_store(self.store_id, file)
+                    if doc is not None:
+                        self.window.core.remote_store.google.files.insert(self.store_id, doc)
+                        msg = "Uploaded file: {}/{}".format((num + 1), len(self.files))
+                        self.signals.status.emit("upload_files", msg)
+                        self.log(msg)
+                        num += 1
+                    else:
+                        self.signals.status.emit("upload_files", "Failed to upload file: {}".format(os.path.basename(file)))
+                except Exception as e:
+                    self.window.core.debug.log(e)
+                    self.signals.status.emit("upload_files", "Failed to upload file: {}".format(os.path.basename(file)))
+            if not silent:
+                self.signals.finished.emit("upload_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("upload_files", e)
+            return False
+
+    def import_files(self, silent: bool = False) -> bool:
+        """
+        Import documents from API
+
+        :param silent: silent mode
+        """
+        try:
+            if self.store_id is None:
+                self.log("Importing all documents...")
+                self.window.core.remote_store.google.files.truncate_local()  # clear local DB (all)
+                num = self.window.core.api.google.store.import_stores_files(self.callback)  # import all
+            else:
+                self.log("Importing documents for store: {}".format(self.store_id))
+                self.window.core.remote_store.google.files.truncate_local(self.store_id)
+                items = self.window.core.api.google.store.import_store_files(self.store_id, [], callback=self.callback)
+                num = len(items)
+            if not silent:
+                self.signals.finished.emit("import_files", self.store_id, num)
+            return True
+        except Exception as e:
+            self.log("API error: {}".format(e))
+            self.signals.error.emit("import_files", e)
+            return False
+
+    def callback(self, msg: str):
+        """Log callback"""
+        self.log(msg)
+
+    def log(self, msg: str):
+        """Log message"""
+        self.signals.log.emit(self.mode, msg)
+
+    def cleanup(self):
+        """Cleanup resources after worker execution."""
+        sig = self.signals
+        self.signals = None
+        if sig is not None:
+            try:
+                sig.deleteLater()
+            except RuntimeError:
+                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: 2025.12.28 00:00:00                  #
+# Updated Date: 2026.01.03 17:00:00                  #
 # ================================================== #
 
 from openai import OpenAI
@@ -22,6 +22,7 @@ from pygpt_net.core.types import (
     MODE_COMPUTER,
 )
 from pygpt_net.core.bridge.context import BridgeContext
+from pygpt_net.core.types.chunk import ChunkType
 from pygpt_net.item.model import ModelItem
 
 from .audio import Audio
@@ -116,10 +117,12 @@ class ApiOpenAI:
         ctx = context.ctx
         ai_name = ctx.output_name
         thread_id = ctx.thread  # from ctx
+        ctx.chunk_type = ChunkType.API_CHAT  # default: ChatCompletion API
 
         # --- Responses API ----
         use_responses_api = self.responses.is_enabled(model, mode, parent_mode, is_expert_call, preset)
-        ctx.use_responses_api = use_responses_api  # set in context
+        if use_responses_api:
+            ctx.chunk_type = ChunkType.API_CHAT_RESPONSES # Responses API
 
         fixtures = self.window.controller.debug.fixtures
 
@@ -137,13 +140,14 @@ class ApiOpenAI:
 
         # completion
         if mode == MODE_COMPLETION:
+            ctx.chunk_type = ChunkType.API_COMPLETION
             response = self.completion.send(
                 context=context,
                 extra=extra,
             )
             used_tokens = self.completion.get_used_tokens()
 
-        # chat, audio (OpenAI) | research (Perplexity)
+        # chat, audio (OpenAI) | research (deep research, Perplexity)
         elif mode in [
             MODE_CHAT,
             MODE_AUDIO,

pygpt_net/provider/api/openai/computer.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.26 18:00:00                  #
+# Updated Date: 2026.01.02 02:00:00                  #
 # ================================================== #
 
 import json
@@ -39,11 +39,20 @@ class Computer:
         Get Computer use tool
         :return: dict
         """
+        is_sandbox = bool(self.window.core.config.get("remote_tools.computer_use.sandbox", False))
         env = self.get_current_env()
         screen = self.window.app.primaryScreen()
         size = screen.size()
         screen_x = size.width()
         screen_y = size.height()
+
+        # if sandbox, get resolution from plugin settings (Playwright viewport)
+        if is_sandbox:
+            try:
+                screen_x = int(self.window.core.plugins.get_option("cmd_mouse_control", "sandbox_viewport_w"))
+                screen_y = int(self.window.core.plugins.get_option("cmd_mouse_control", "sandbox_viewport_h"))
+            except Exception:
+                pass
         return {
             "type": "computer_use_preview",
             "display_width": screen_x,

pygpt_net/provider/api/openai/store.py

@@ -6,13 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.02 22:00:00                  #
+# Updated Date: 2026.01.02 20:00:00                  #
 # ================================================== #
 
 import os
 from typing import Optional, List
 
-from pygpt_net.item.assistant import AssistantStoreItem
+from pygpt_net.item.store import RemoteStoreItem
 
 
 class Store:
@@ -273,7 +273,7 @@ class Store:
             for remote in stores.data:
                 id = remote.id
                 if id not in items:
-                    items[id] = AssistantStoreItem()
+                    items[id] = RemoteStoreItem()
                 tmp_name = remote.name
                 if tmp_name is None:
                     items[id].is_thread = True  # tmp store for thread
@@ -281,8 +281,8 @@ class Store:
                 items[id].id = id
                 items[id].name = tmp_name
                 items[id].file_ids = []
-                items[id].status = self.window.core.assistants.store.parse_status(remote)
-                self.window.core.assistants.store.append_status(items[id], items[id].status)
+                items[id].status = self.window.core.remote_store.openai.parse_status(remote)
+                self.window.core.remote_store.openai.append_status(items[id], items[id].status)
                 self.log("Imported vector store: " + id, callback)
             # next page
             if stores.has_more:
@@ -633,7 +633,7 @@ class Store:
                     if id not in items:
                         items.append(id)
                         data = self.get_file(remote.id)
-                        self.window.core.assistants.files.insert(store_id, data)  # add remote file to DB
+                        self.window.core.remote_store.openai.files.insert(store_id, data)  # add remote file to DB
                         msg = "Imported file ID {} to store {}".format(remote.id, store_id)
                         self.log(msg, callback)
                 except Exception as e:

pygpt_net/provider/api/openai/worker/importer.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.11 14:00:00                  #
+# Updated Date: 2026.01.02 19:00:00                  #
 # ================================================== #
 
 import os
@@ -36,17 +36,17 @@ class Importer(QObject):
         if mode == "assistants":
             self.window.controller.assistant.batch.handle_imported_assistants_failed(err)
         elif mode == "import_files":
-            self.window.controller.assistant.batch.handle_imported_files_failed(err)
+            self.window.controller.remote_store.openai.batch.handle_imported_files_failed(err)
         elif mode == "truncate_files":
-            self.window.controller.assistant.batch.handle_truncated_files_failed(err)
+            self.window.controller.remote_store.openai.batch.handle_truncated_files_failed(err)
         elif mode == "upload_files":
-            self.window.controller.assistant.batch.handle_uploaded_files_failed(err)
+            self.window.controller.remote_store.openai.batch.handle_uploaded_files_failed(err)
         elif mode in "vector_stores":
-            self.window.controller.assistant.batch.handle_imported_stores_failed(err)
+            self.window.controller.remote_store.openai.batch.handle_imported_stores_failed(err)
         elif mode in "truncate_vector_stores":
-            self.window.controller.assistant.batch.handle_truncated_stores_failed(err)
+            self.window.controller.remote_store.openai.batch.handle_truncated_stores_failed(err)
         elif mode in "refresh_vector_stores":
-            self.window.controller.assistant.batch.handle_refreshed_stores_failed(err)
+            self.window.controller.remote_store.openai.batch.handle_refreshed_stores_failed(err)
 
     @Slot(str, str, int)
     def handle_finished(self, mode: str, store_id: str = None, num: int = 0):
@@ -60,17 +60,17 @@ class Importer(QObject):
         if mode == "assistants":
             self.window.controller.assistant.batch.handle_imported_assistants(num)
         elif mode == "import_files":
-            self.window.controller.assistant.batch.handle_imported_files(num)
+            self.window.controller.remote_store.openai.batch.handle_imported_files(num)
         elif mode == "truncate_files":
-            self.window.controller.assistant.batch.handle_truncated_files(store_id, num)
+            self.window.controller.remote_store.openai.batch.handle_truncated_files(store_id, num)
         elif mode == "upload_files":
-            self.window.controller.assistant.batch.handle_uploaded_files(num)
+            self.window.controller.remote_store.openai.batch.handle_uploaded_files(num)
         elif mode == "vector_stores":
-            self.window.controller.assistant.batch.handle_imported_stores(num)
+            self.window.controller.remote_store.openai.batch.handle_imported_stores(num)
         elif mode == "truncate_vector_stores":
-            self.window.controller.assistant.batch.handle_truncated_stores(num)
+            self.window.controller.remote_store.openai.batch.handle_truncated_stores(num)
         elif mode == "refresh_vector_stores":
-            self.window.controller.assistant.batch.handle_refreshed_stores(num)
+            self.window.controller.remote_store.openai.batch.handle_refreshed_stores(num)
 
     @Slot(str, str)
     def handle_status(self, mode: str, msg: str):
@@ -264,10 +264,10 @@ class ImportWorker(QRunnable):
         """
         try:
             self.log("Importing vector stores...")
-            self.window.core.assistants.store.clear()
+            self.window.core.remote_store.openai.clear()
             items = {}
             self.window.core.api.openai.store.import_stores(items, callback=self.callback)
-            self.window.core.assistants.store.import_items(items)
+            self.window.core.remote_store.openai.import_items(items)
             if not silent:
                 self.signals.finished.emit("vector_stores", self.store_id, len(items))
             return True
@@ -286,8 +286,8 @@ class ImportWorker(QRunnable):
         try:
             self.log("Truncating stores...")
             num = self.window.core.api.openai.store.remove_all(callback=self.callback)
-            self.window.core.assistants.store.items = {}
-            self.window.core.assistants.store.save()
+            self.window.core.remote_store.openai.items = {}
+            self.window.core.remote_store.openai.save()
             if not silent:
                 self.signals.finished.emit("truncate_vector_stores", self.store_id, num)
             return True
@@ -306,11 +306,11 @@ class ImportWorker(QRunnable):
         try:
             self.log("Refreshing stores...")
             num = 0
-            stores = self.window.core.assistants.store.items
+            stores = self.window.core.remote_store.openai.items
             for id in stores:
                 store = stores[id]
                 try:
-                    self.window.controller.assistant.store.refresh_store(store, update=False)
+                    self.window.controller.remote_store.openai.refresh_store(store, update=False)
                     num += 1
                 except Exception as e:
                     self.log("Failed to refresh store: {}".format(id))
@@ -334,12 +334,12 @@ class ImportWorker(QRunnable):
             # if empty store_id, truncate all files, otherwise truncate only store files
             if self.store_id is None:
                 self.log("Truncating all files...")
-                self.window.core.assistants.files.truncate() # clear all files
+                self.window.core.remote_store.openai.files.truncate() # clear all files
                 # remove all files in API
                 num = self.window.core.api.openai.store.remove_files(callback=self.callback)
             else:
                 self.log("Truncating files for store: {}".format(self.store_id))
-                self.window.core.assistants.files.truncate(self.store_id)  # clear store files, remove from stores / DB
+                self.window.core.remote_store.openai.files.truncate(self.store_id)  # clear store files, remove from stores / DB
                 # remove store files in API
                 num = self.window.core.api.openai.store.remove_store_files(
                     self.store_id,
@@ -373,7 +373,7 @@ class ImportWorker(QRunnable):
                         )
                         if stored_file is not None:
                             data = self.window.core.api.openai.store.get_file(file_id)
-                            self.window.core.assistants.files.insert(self.store_id, data)  # insert to DB
+                            self.window.core.remote_store.openai.files.insert(self.store_id, data)  # insert to DB
                             msg = "Uploaded file: {}/{}".format((num + 1), len(self.files))
                             self.signals.status.emit("upload_files", msg)
                             self.log(msg)
@@ -402,11 +402,11 @@ class ImportWorker(QRunnable):
         try:
             if self.store_id is None:
                 self.log("Importing all files...")
-                self.window.core.assistants.files.truncate_local()  # clear local DB (all)
+                self.window.core.remote_store.openai.files.truncate_local()  # clear local DB (all)
                 num = self.window.core.api.openai.store.import_stores_files(self.callback)  # import all files
             else:
                 self.log("Importing files for store: {}".format(self.store_id))
-                self.window.core.assistants.files.truncate_local(self.store_id)  # clear local DB (all)
+                self.window.core.remote_store.openai.files.truncate_local(self.store_id)  # clear local DB (all)
                 items = self.window.core.api.openai.store.import_store_files(
                     self.store_id,
                     [],