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

pygpt_net/provider/api/google/computer.py

@@ -0,0 +1,190 @@
+#!/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 Szczyglinski                  #
+# Updated Date: 2026.01.02 02:00:00                  #
+# ================================================== #
+
+import json
+import time
+from typing import Dict, Any, List, Tuple, Optional
+
+from google.genai import types as gtypes
+from pygpt_net.item.ctx import CtxItem
+
+
+class Computer:
+    def __init__(self, window=None):
+        """
+        Google Gemini Computer Use adapter
+
+        This adapter passes Google Gemini function calls and action events
+        directly to the plugin worker without translating names to legacy
+        commands. The workers (host and sandbox) implement the full set
+        of functions and handle any coordinate conversions themselves.
+        """
+        self.window = window
+        self._seq = 0
+
+    # --------------- Tool spec --------------- #
+
+    def get_current_env(self) -> Dict[str, Any]:
+        idx = self.window.ui.nodes["computer_env"].currentIndex()
+        return self.window.ui.nodes["computer_env"].itemData(idx)
+
+    def _map_env(self) -> gtypes.Environment:
+        return gtypes.Environment.ENVIRONMENT_BROWSER
+        env = self.get_current_env()
+        val = ""
+        if isinstance(env, str):
+            val = env.lower()
+        elif isinstance(env, dict):
+            val = str(env.get("value") or env.get("name") or env).lower()
+        if "mac" in val:
+            return gtypes.Environment.ENVIRONMENT_MAC
+        if "windows" in val or "win" in val:
+            return gtypes.Environment.ENVIRONMENT_WINDOWS
+        if "linux" in val:
+            return gtypes.Environment.ENVIRONMENT_LINUX
+        return gtypes.Environment.ENVIRONMENT_BROWSER
+
+    def get_tool(self) -> gtypes.Tool:
+        return gtypes.Tool(
+            computer_use=gtypes.ComputerUse(
+                environment=self._map_env(),
+            )
+        )
+
+    # --------------- Streaming handling --------------- #
+
+    def _next_id(self) -> str:
+        self._seq += 1
+        return f"gc-{int(time.time()*1000)}-{self._seq}"
+
+    def _append_call(self, tool_calls: list, id_: str, call_id: str, name: str, args: dict) -> None:
+        tool_calls.append({
+            "id": id_,
+            "call_id": call_id,
+            "type": "computer_call",
+            "function": {
+                "name": name,
+                "arguments": json.dumps(args or {}),
+            }
+        })
+
+    def _append_screenshot(self, tool_calls: list, id_: str, call_id: str) -> None:
+        self._append_call(tool_calls, id_, call_id, "get_screenshot", {})
+
+    def _record_pending_checks(self, ctx: CtxItem, pending: Optional[list]) -> None:
+        if not pending:
+            return
+        ctx.extra["pending_safety_checks"] = []
+        for item in pending:
+            try:
+                ctx.extra["pending_safety_checks"].append({
+                    "id": getattr(item, "id", None),
+                    "code": getattr(item, "code", None),
+                    "message": getattr(item, "message", None),
+                })
+            except Exception:
+                pass
+
+    def handle_stream_chunk(self, ctx: CtxItem, chunk, tool_calls: list) -> Tuple[List, bool]:
+        """
+        Handle function_call parts (Gemini) and older action-shaped events.
+        All functions are passed through unchanged to the worker.
+
+        Returns: updated tool_calls and a boolean indicating if there were calls.
+        """
+        has_calls = False
+
+        # Case A: Google SDK function_call parts (recommended)
+        for fname, fargs in self._iter_function_calls(chunk):
+            if not fname:
+                continue
+            id_ = self._next_id()
+            call_id = id_
+            try:
+                self._append_call(tool_calls, id_, call_id, fname, fargs or {})
+                has_calls = True
+            except Exception as e:
+                print(f"Gemini pass-through error for function '{fname}': {e}")
+
+        # Case B: Older/OpenAI-shaped events embedded as chunk.item.action
+        try:
+            item = getattr(chunk, "item", None)
+            if item and getattr(item, "type", "") == "computer_call":
+                id_ = getattr(item, "id", None) or self._next_id()
+                call_id = getattr(item, "call_id", None) or id_
+                action = getattr(item, "action", None)
+                if action:
+                    name, args = self._pass_action(action)
+                    if name:
+                        self._append_call(tool_calls, id_, call_id, name, args)
+                        has_calls = True
+                # optional pending safety checks
+                if getattr(item, "pending_safety_checks", None):
+                    self._record_pending_checks(ctx, item.pending_safety_checks)
+        except Exception as e:
+            print(f"Gemini action stream parse error: {e}")
+
+        return tool_calls, has_calls
+
+    # --------------- Parsers --------------- #
+
+    def _iter_function_calls(self, resp) -> List[tuple]:
+        calls = []
+        try:
+            candidates = getattr(resp, "candidates", None)
+            if candidates:
+                for cand in candidates:
+                    content = getattr(cand, "content", None)
+                    if content:
+                        parts = getattr(content, "parts", None)
+                        if parts:
+                            for part in parts:
+                                fc = getattr(part, "function_call", None)
+                                if fc:
+                                    name = getattr(fc, "name", None)
+                                    args = getattr(fc, "args", {}) or {}
+                                    calls.append((name, args))
+            else:
+                if isinstance(resp, dict):
+                    content = resp.get("content", {})
+                    parts = content.get("parts", [])
+                    for part in parts:
+                        if "function_call" in part:
+                            fc = part["function_call"]
+                            calls.append((fc.get("name"), fc.get("args", {})))
+        except Exception as e:
+            print(f"Gemini: failed to parse function_call: {e}")
+        return calls
+
+    def _pass_action(self, action) -> Tuple[Optional[str], dict]:
+        """
+        Convert old-style action object into a direct function call name + args,
+        without changing the semantic names (workers handle details).
+        """
+        try:
+            atype = getattr(action, "type", None)
+            if not atype:
+                return None, {}
+            atype = str(atype)
+
+            # Build args by introspection; workers know how to interpret them
+            args = {}
+            for attr in ("x", "y", "button", "scroll_x", "scroll_y", "keys", "text", "path"):
+                if hasattr(action, attr):
+                    args[attr] = getattr(action, attr)
+
+            if atype == "double_click":
+                args["num_clicks"] = 2
+
+            return atype, args
+        except Exception as e:
+            print(f"Gemini: pass_action error: {e}")
+            return None, {}

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.30 22:00:00                  #
+# Updated Date: 2025.12.31 16:00:00                  #
 # ================================================== #
 
 import mimetypes
@@ -55,6 +55,7 @@ class Image:
         prompt = context.prompt
         num = int(extra.get("num", 1))
         inline = bool(extra.get("inline", False))
+        extra_prompt = extra.get("extra_prompt", "")
 
         # decide sub-mode based on attachments
         sub_mode = self.MODE_GENERATE
@@ -79,6 +80,7 @@ class Image:
         worker.raw = self.window.core.config.get('img_raw')
         worker.num = num
         worker.inline = inline
+        worker.extra_prompt = extra_prompt
 
         # remix: previous image reference (ID/URI/path) from extra
         worker.image_id = extra.get("image_id")
@@ -129,6 +131,7 @@ class ImageWorker(QRunnable):
         self.input_prompt = ""
         self.system_prompt = ""
         self.inline = False
+        self.extra_prompt: Optional[str] = None
         self.raw = False
         self.num = 1
         self.resolution = "1024x1024"  # used to derive aspect ratio or image_size
@@ -178,6 +181,18 @@ class ImageWorker(QRunnable):
                     self.signals.error.emit(e)
                     self.signals.status.emit(trans('img.status.prompt.error') + ": " + str(e))
 
+            # Decide how to apply negative prompt: native param on Vertex Imagen 3.0 (-001) or inline fallback.
+            use_param = (
+                bool(self.extra_prompt and str(self.extra_prompt).strip())
+                and self._using_vertex()
+                and self._imagen_supports_negative_prompt(self.model)
+            )
+            if (self.extra_prompt and str(self.extra_prompt).strip()) and not use_param:
+                try:
+                    self.input_prompt = self._merge_negative_prompt(self.input_prompt or "", self.extra_prompt)
+                except Exception:
+                    pass
+
             paths: List[str] = []
 
             # Remix path: if image_id provided, prefer image-to-image remix using the given identifier.
@@ -198,11 +213,21 @@ class ImageWorker(QRunnable):
                             mask_dilation=0.0,
                         ),
                     )
-                    cfg = gtypes.EditImageConfig(
+                    # Prepare edit config with optional negative prompt when supported
+                    cfg_kwargs = dict(
                         edit_mode="EDIT_MODE_DEFAULT",
                         number_of_images=min(self.num, self.imagen_max_num),
                         include_rai_reason=True,
                     )
+                    if self.extra_prompt and self._imagen_supports_negative_prompt(self.model):
+                        cfg_kwargs["negative_prompt"] = self.extra_prompt
+                    try:
+                        cfg = gtypes.EditImageConfig(**cfg_kwargs)
+                    except Exception:
+                        # Fallback without negative_prompt if SDK doesn't recognize it
+                        cfg_kwargs.pop("negative_prompt", None)
+                        cfg = gtypes.EditImageConfig(**cfg_kwargs)
+
                     resp = self.client.models.edit_image(
                         model="imagen-3.0-capability-001",
                         prompt=self.input_prompt or "",
@@ -355,12 +380,34 @@ class ImageWorker(QRunnable):
         mid = str(model_id).lower()
         return "imagen" in mid and "generate" in mid
 
+    def _imagen_supports_negative_prompt(self, model_id: str) -> bool:
+        """
+        Return True if the Imagen model supports native negative_prompt.
+        Supported: imagen-3.0-generate-001, imagen-3.0-fast-generate-001, imagen-3.0-capability-001.
+        """
+        mid = str(model_id or "").lower()
+        return any(x in mid for x in (
+            "imagen-3.0-generate-001",
+            "imagen-3.0-fast-generate-001",
+            "imagen-3.0-capability-001",
+        ))
+
     def _imagen_generate(self, prompt: str, num: int, resolution: str):
         """Imagen text-to-image."""
         aspect = self._aspect_from_resolution(resolution)
-        cfg = gtypes.GenerateImagesConfig(number_of_images=num)
+        # Build config with optional negative_prompt when supported by model and provided.
+        cfg_kwargs: Dict[str, Any] = {"number_of_images": num}
         if aspect:
-            cfg.aspect_ratio = aspect
+            cfg_kwargs["aspect_ratio"] = aspect
+        if self.extra_prompt and self._imagen_supports_negative_prompt(self.model):
+            cfg_kwargs["negative_prompt"] = self.extra_prompt
+        try:
+            cfg = gtypes.GenerateImagesConfig(**cfg_kwargs)
+        except Exception:
+            # Fallback without negative_prompt if SDK doesn't recognize it
+            cfg_kwargs.pop("negative_prompt", None)
+            cfg = gtypes.GenerateImagesConfig(**cfg_kwargs)
+
         return self.client.models.generate_images(
             model=self.model,
             prompt=prompt,
@@ -401,11 +448,19 @@ class ImageWorker(QRunnable):
             )
             edit_mode = "EDIT_MODE_BGSWAP"
 
-        cfg = gtypes.EditImageConfig(
+        # Build edit config with optional negative_prompt
+        cfg_kwargs = dict(
             edit_mode=edit_mode,
             number_of_images=min(num, self.imagen_max_num),
             include_rai_reason=True,
         )
+        if self.extra_prompt and self._imagen_supports_negative_prompt(self.model):
+            cfg_kwargs["negative_prompt"] = self.extra_prompt
+        try:
+            cfg = gtypes.EditImageConfig(**cfg_kwargs)
+        except Exception:
+            cfg_kwargs.pop("negative_prompt", None)
+            cfg = gtypes.EditImageConfig(**cfg_kwargs)
 
         # Ensure capability model for edit
         model_id = "imagen-3.0-capability-001"
@@ -806,4 +861,17 @@ class ImageWorker(QRunnable):
             try:
                 sig.deleteLater()
             except RuntimeError:
-                pass
+                pass
+
+    # ---------- prompt utilities ----------
+
+    @staticmethod
+    def _merge_negative_prompt(prompt: str, negative: Optional[str]) -> str:
+        """
+        Append a negative prompt to the main text prompt when the provider has no native negative_prompt field.
+        """
+        base = (prompt or "").strip()
+        neg = (negative or "").strip()
+        if not neg:
+            return base
+        return (base + ("\n" if base else "") + f"Negative prompt: {neg}").strip()

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: 2025.08.31 23:00:00                  #
+# Updated Date: 2026.01.02 19:00:00                  #
 # ================================================== #
 
 import json
@@ -97,7 +97,7 @@ class Realtime:
 
         # Tools
         tools = self.window.core.api.google.tools.prepare(model, context.external_functions)
-        remote_tools = self.window.core.api.google.build_remote_tools(model)
+        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
 

pygpt_net/provider/api/google/remote_tools.py

@@ -0,0 +1,93 @@
+#!/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 19:00:00                  #
+# ================================================== #
+
+from google.genai import types as gtypes
+
+from pygpt_net.item.model import ModelItem
+
+
+class RemoteTools:
+    def __init__(self, window=None):
+        """
+        Remote Tools helpers for Google GenAI.
+
+        :param window: Window instance
+        """
+        self.window = window
+
+    def build_remote_tools(self, model: ModelItem = None) -> list:
+        """
+        Build Google GenAI remote tools based on config flags.
+        - remote_tools.google.web_search: enables grounding via Google Search (Gemini 2.x)
+          or GoogleSearchRetrieval (Gemini 1.5 fallback).
+        - remote_tools.google.code_interpreter: enables code execution tool.
+
+        Returns a list of gtypes.Tool objects (can be empty).
+
+        :param model: ModelItem
+        :return: list of gtypes.Tool
+        """
+        tools: list = []
+        cfg = self.window.core.config
+        model_id = (model.id if model and getattr(model, "id", None) else "").lower()
+        is_web = self.window.controller.chat.remote_tools.enabled(model, "web_search")  # get global config
+
+        # Google Search tool
+        if is_web and "image" not in model.id:
+            try:
+                if not model_id.startswith("gemini-1.5") and not model_id.startswith("models/gemini-1.5"):
+                    # Gemini 2.x uses GoogleSearch
+                    tools.append(gtypes.Tool(google_search=gtypes.GoogleSearch()))
+                else:
+                    # Gemini 1.5 fallback uses GoogleSearchRetrieval
+                    # Note: Supported only for 1.5 models.
+                    tools.append(gtypes.Tool(
+                        google_search_retrieval=gtypes.GoogleSearchRetrieval()
+                    ))
+            except Exception as e:
+                # Do not break the request if tool construction fails
+                self.window.core.debug.log(e)
+
+        # Code Execution tool
+        if cfg.get("remote_tools.google.code_interpreter") and "image" not in model.id:
+            try:
+                tools.append(gtypes.Tool(code_execution=gtypes.ToolCodeExecution))
+            except Exception as e:
+                self.window.core.debug.log(e)
+
+        # URL Context tool
+        if cfg.get("remote_tools.google.url_ctx") and "image" not in model.id:
+            try:
+                # Supported on Gemini 2.x+ models (not on 1.5)
+                if not model_id.startswith("gemini-1.5") and not model_id.startswith("models/gemini-1.5"):
+                    tools.append(gtypes.Tool(url_context=gtypes.UrlContext))
+            except Exception as e:
+                self.window.core.debug.log(e)
+
+        # Google Maps
+        if cfg.get("remote_tools.google.maps") and "image" not in model.id:
+            try:
+                tools.append(gtypes.Tool(google_maps=gtypes.GoogleMaps()))
+            except Exception as e:
+                self.window.core.debug.log(e)
+
+        # File search
+        if cfg.get("remote_tools.google.file_search") and "image" not in model.id:
+            store_ids = cfg.get("remote_tools.google.file_search.args", "")
+            file_search_store_names = [s.strip() for s in store_ids.split(",") if s.strip()]
+            try:
+                tools.append(gtypes.Tool(file_search=gtypes.FileSearch(
+                    file_search_store_names=file_search_store_names,
+                )))
+            except Exception as e:
+                self.window.core.debug.log(e)
+
+        return tools