pygpt-net 2.6.27__py3-none-any.whl → 2.6.29__py3-none-any.whl

pygpt_net/plugin/wikipedia/worker.py

@@ -0,0 +1,430 @@
+#!/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: 2025.08.27 20:18:26                  #
+# ================================================== #
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from PySide6.QtCore import Slot
+from pygpt_net.plugin.base.worker import BaseWorker, BaseSignals
+
+# Lazy import
+try:
+    import wikipedia as wiki
+    from wikipedia.exceptions import (
+        DisambiguationError,
+        PageError,
+        RedirectError,
+        HTTPTimeoutError,
+        WikipediaException,
+    )
+except Exception:  # fallback mapping for type hints
+    wiki = None
+    DisambiguationError = PageError = RedirectError = HTTPTimeoutError = WikipediaException = Exception  # type: ignore
+
+
+class WorkerSignals(BaseSignals):
+    pass
+
+
+class Worker(BaseWorker):
+    """
+    Wikipedia plugin worker: language, search, suggest, summary, page, section, random, geosearch, open.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(Worker, self).__init__()
+        self.signals = WorkerSignals()
+        self.args = args
+        self.kwargs = kwargs
+        self.plugin = None
+        self.cmds = None
+        self.ctx = None
+        self.msg = None
+
+    # ---------------------- Core runner ----------------------
+
+    @Slot()
+    def run(self):
+        try:
+            responses = []
+            self._apply_settings()  # sync module settings with plugin options
+            for item in self.cmds:
+                if self.is_stopped():
+                    break
+                try:
+                    response = None
+                    if item["cmd"] in self.plugin.allowed_cmds and self.plugin.has_cmd(item["cmd"]):
+
+                        # -------- Language --------
+                        if item["cmd"] == "wp_set_lang":
+                            response = self.cmd_wp_set_lang(item)
+                        elif item["cmd"] == "wp_get_lang":
+                            response = self.cmd_wp_get_lang(item)
+                        elif item["cmd"] == "wp_languages":
+                            response = self.cmd_wp_languages(item)
+
+                        # -------- Search / Suggest --------
+                        elif item["cmd"] == "wp_search":
+                            response = self.cmd_wp_search(item)
+                        elif item["cmd"] == "wp_suggest":
+                            response = self.cmd_wp_suggest(item)
+
+                        # -------- Read --------
+                        elif item["cmd"] == "wp_summary":
+                            response = self.cmd_wp_summary(item)
+                        elif item["cmd"] == "wp_page":
+                            response = self.cmd_wp_page(item)
+                        elif item["cmd"] == "wp_section":
+                            response = self.cmd_wp_section(item)
+
+                        # -------- Discover --------
+                        elif item["cmd"] == "wp_random":
+                            response = self.cmd_wp_random(item)
+                        elif item["cmd"] == "wp_geosearch":
+                            response = self.cmd_wp_geosearch(item)
+
+                        # -------- Utilities --------
+                        elif item["cmd"] == "wp_open":
+                            response = self.cmd_wp_open(item)
+
+                        if response:
+                            responses.append(response)
+
+                except DisambiguationError as e:
+                    responses.append(self.make_response(item, self._wrap_disambig(e)))
+                except (PageError, RedirectError, HTTPTimeoutError, WikipediaException) as e:
+                    responses.append(self.make_response(item, self.throw_error(e)))
+                except Exception as e:
+                    responses.append(self.make_response(item, self.throw_error(e)))
+
+            if responses:
+                self.reply_more(responses)
+            if self.msg is not None:
+                self.status(self.msg)
+        except Exception as e:
+            self.error(e)
+        finally:
+            self.cleanup()
+
+    # ---------------------- Helpers ----------------------
+
+    def _require_lib(self):
+        if wiki is None:
+            raise RuntimeError("Missing 'wikipedia' package. Install with: pip install wikipedia")
+
+    def _apply_settings(self):
+        self._require_lib()
+        # Keep module-level settings in sync with plugin options
+        lang = (self.plugin.get_option_value("lang") or "en").strip()
+        auto_rate = bool(self.plugin.get_option_value("rate_limit") or True)
+        ua = (self.plugin.get_option_value("user_agent") or "").strip()
+        try:
+            wiki.set_lang(lang)
+        except Exception:
+            pass
+        try:
+            wiki.set_rate_limit(auto_rate)
+        except Exception:
+            pass
+        if ua:
+            try:
+                wiki.set_user_agent(ua)
+            except Exception:
+                pass
+
+    def _opt_bool(self, key: str, default: bool) -> bool:
+        v = self.plugin.get_option_value(key)
+        return bool(default if v is None else v)
+
+    def _opt_int(self, key: str, default: int) -> int:
+        v = self.plugin.get_option_value(key)
+        try:
+            return int(default if v is None else v)
+        except Exception:
+            return default
+
+    def _params_bool(self, params: dict, key: str, fallback_opt: Optional[str], default: bool) -> bool:
+        if key in params and params[key] is not None:
+            return bool(params[key])
+        if fallback_opt:
+            return self._opt_bool(fallback_opt, default)
+        return bool(default)
+
+    def _params_int(self, params: dict, key: str, fallback_opt: Optional[str], default: int) -> int:
+        if key in params and params[key] is not None:
+            try:
+                return int(params[key])
+            except Exception:
+                return default
+        if fallback_opt:
+            return self._opt_int(fallback_opt, default)
+        return int(default)
+
+    def _clip_text(self, text: str, max_chars: Optional[int]) -> str:
+        if text is None:
+            return ""
+        if not max_chars or max_chars <= 0:
+            return text
+        if len(text) <= max_chars:
+            return text
+        return text[: max_chars - 3] + "..."
+
+    def _clip_list(self, items: List[Any], max_items: Optional[int]) -> List[Any]:
+        if not isinstance(items, list):
+            return []
+        if not max_items or max_items <= 0 or len(items) <= max_items:
+            return items
+        return items[:max_items]
+
+    def _wrap_disambig(self, e: DisambiguationError) -> dict:
+        # Provide options to let the assistant choose a target
+        return {
+            "error": "Disambiguation required",
+            "type": "DisambiguationError",
+            "title": getattr(e, "title", None),
+            "options": getattr(e, "options", []),
+        }
+
+    def _auto_suggest_param(self, p: dict) -> bool:
+        return self._params_bool(p, "auto_suggest", "auto_suggest", True)
+
+    def _redirect_param(self, p: dict) -> bool:
+        return self._params_bool(p, "redirect", "redirect", True)
+
+    # Decide whether to return full content (no clipping)
+    def _full_content_param(self, p: dict) -> bool:
+        if p.get("full") is not None:
+            return bool(p["full"])
+        if p.get("no_clip") is not None:  # alias
+            return bool(p["no_clip"])
+        return bool(self.plugin.get_option_value("content_full_default") or False)
+
+    # ---------------------- Commands: Language ----------------------
+
+    def cmd_wp_set_lang(self, item: dict) -> dict:
+        p = item.get("params", {})
+        lang = (p.get("lang") or "").strip()
+        if not lang:
+            return self.make_response(item, "Param 'lang' required")
+        self.plugin.set_option_value("lang", lang)
+        self._apply_settings()
+        return self.make_response(item, {"ok": True, "lang": lang})
+
+    def cmd_wp_get_lang(self, item: dict) -> dict:
+        lang = (self.plugin.get_option_value("lang") or "en").strip()
+        return self.make_response(item, {"lang": lang})
+
+    def cmd_wp_languages(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        short = bool(p.get("short", False))
+        langs = wiki.languages()  # dict: code -> localized name
+        if short:
+            data = sorted(list(langs.keys()))
+        else:
+            data = langs
+        max_items = self._opt_int("max_list_items", 50)
+        if isinstance(data, list):
+            data = self._clip_list(data, max_items)
+        elif isinstance(data, dict):
+            data = dict(list(data.items())[:max_items])
+        return self.make_response(item, {"data": data})
+
+    # ---------------------- Commands: Search / Suggest ----------------------
+
+    def cmd_wp_search(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        q = (p.get("q") or p.get("query") or "").strip()
+        if not q:
+            return self.make_response(item, "Param 'q' required")
+        results_limit = self._params_int(p, "results", "results_default", 10)
+        suggestion = bool(p.get("suggestion", False))
+        if suggestion:
+            res, sugg = wiki.search(q, results=results_limit, suggestion=True)
+            return self.make_response(item, {"results": res, "suggestion": sugg})
+        else:
+            res = wiki.search(q, results=results_limit, suggestion=False)
+            return self.make_response(item, {"results": res})
+
+    def cmd_wp_suggest(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        q = (p.get("q") or p.get("query") or "").strip()
+        if not q:
+            return self.make_response(item, "Param 'q' required")
+        sugg = wiki.suggest(q)
+        return self.make_response(item, {"suggestion": sugg})
+
+    # ---------------------- Commands: Read ----------------------
+
+    def cmd_wp_summary(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        title = (p.get("title") or p.get("q") or p.get("query") or "").strip()
+        if not title:
+            return self.make_response(item, "Param 'title' (or 'q') required")
+        sentences = self._params_int(p, "sentences", "summary_sentences", 3)
+        auto_suggest = self._auto_suggest_param(p)
+        redirect = self._redirect_param(p)
+        summary = wiki.summary(title, sentences=sentences, auto_suggest=auto_suggest, redirect=redirect)
+        url = None
+        try:
+            pg = wiki.page(title, auto_suggest=auto_suggest, redirect=redirect)
+            url = getattr(pg, "url", None)
+            title = getattr(pg, "title", title)
+        except Exception:
+            pass
+        return self.make_response(item, {"title": title, "summary": summary, "url": url})
+
+    def cmd_wp_page(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        title = (p.get("title") or "").strip()
+        if not title:
+            return self.make_response(item, "Param 'title' required")
+        auto_suggest = self._auto_suggest_param(p)
+        redirect = self._redirect_param(p)
+        content_chars = self._params_int(p, "content_chars", "content_max_chars", 5000)
+        max_list = self._params_int(p, "max_list_items", "max_list_items", 50)
+        full = self._full_content_param(p)
+
+        include = p.get("include")
+        if not include:
+            include = ["title", "url", "summary", "content", "sections", "categories", "links", "images", "references"]
+
+        pg = wiki.page(title, auto_suggest=auto_suggest, redirect=redirect)
+        data: Dict[str, Any] = {}
+
+        if "title" in include:
+            data["title"] = getattr(pg, "title", title)
+        if "url" in include:
+            data["url"] = getattr(pg, "url", None)
+        if "summary" in include:
+            try:
+                data["summary"] = getattr(pg, "summary", None)
+            except Exception:
+                data["summary"] = None
+        if "content" in include:
+            try:
+                raw = getattr(pg, "content", None)
+                data["content_body"] = raw if full else self._clip_text(raw, content_chars)
+            except Exception:
+                data["content_body"] = None
+        if "sections" in include:
+            try:
+                data["sections"] = self._clip_list(getattr(pg, "sections", []), max_list)
+            except Exception:
+                data["sections"] = []
+        if "categories" in include:
+            try:
+                data["categories"] = self._clip_list(getattr(pg, "categories", []), max_list)
+            except Exception:
+                data["categories"] = []
+        if "links" in include:
+            try:
+                data["links"] = self._clip_list(getattr(pg, "links", []), max_list)
+            except Exception:
+                data["links"] = []
+        if "images" in include:
+            try:
+                data["images"] = self._clip_list(getattr(pg, "images", []), max_list)
+            except Exception:
+                data["images"] = []
+        if "references" in include:
+            try:
+                data["references"] = self._clip_list(getattr(pg, "references", []), max_list)
+            except Exception:
+                data["references"] = []
+
+        if bool(p.get("open", False)):
+            try:
+                if data.get("url"):
+                    self.plugin.open_url(data["url"])
+            except Exception:
+                pass
+
+        return self.make_response(item, data)
+
+    def cmd_wp_section(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        title = (p.get("title") or "").strip()
+        section = (p.get("section") or "").strip()
+        if not title or not section:
+            return self.make_response(item, "Params 'title' and 'section' required")
+        auto_suggest = self._auto_suggest_param(p)
+        redirect = self._redirect_param(p)
+        content_chars = self._params_int(p, "content_chars", "content_max_chars", 5000)
+        full = self._full_content_param(p)
+
+        pg = wiki.page(title, auto_suggest=auto_suggest, redirect=redirect)
+        txt = pg.section(section)
+
+        return self.make_response(item, {
+            "title": getattr(pg, "title", title),
+            "section": section,
+            "content_body": (txt or "") if full else self._clip_text(txt or "", content_chars),
+            "url": getattr(pg, "url", None),
+        })
+
+    # ---------------------- Commands: Discover ----------------------
+
+    def cmd_wp_random(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        count = self._params_int(p, "results", "results_default", 1)
+        res = wiki.random(pages=count)
+        if isinstance(res, str):
+            res = [res]
+        return self.make_response(item, {"results": res})
+
+    def cmd_wp_geosearch(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        lat = p.get("lat") or p.get("latitude")
+        lon = p.get("lon") or p.get("lng") or p.get("longitude")
+        if lat is None or lon is None:
+            return self.make_response(item, "Params 'lat' and 'lon' required")
+        try:
+            lat = float(lat)
+            lon = float(lon)
+        except Exception:
+            return self.make_response(item, "Params 'lat' and 'lon' must be numbers")
+        radius = self._params_int(p, "radius", None, 1000)
+        results_limit = self._params_int(p, "results", "results_default", 10)
+        title = p.get("title")
+        res = wiki.geosearch(latitude=lat, longitude=lon, title=title, results=results_limit, radius=radius)
+        return self.make_response(item, {"results": res})
+
+    # ---------------------- Commands: Utilities ----------------------
+
+    def cmd_wp_open(self, item: dict) -> dict:
+        self._require_lib()
+        p = item.get("params", {})
+        url = p.get("url")
+        title = p.get("title")
+        auto_suggest = self._auto_suggest_param(p)
+        redirect = self._redirect_param(p)
+
+        if not url and not title:
+            return self.make_response(item, "Provide 'url' or 'title'")
+        if not url:
+            pg = wiki.page(title, auto_suggest=auto_suggest, redirect=redirect)
+            url = getattr(pg, "url", None)
+        if not url:
+            return self.make_response(item, "Unable to resolve URL")
+        try:
+            self.plugin.open_url(url)
+        except Exception:
+            pass
+        return self.make_response(item, {"ok": True, "url": url})

pygpt_net/provider/core/config/patch.py

@@ -2344,6 +2344,17 @@ class Patch:
                     data["api_endpoint_open_router"] = "https://openrouter.ai/api/v1"
                 updated = True
 
+            # < 2.6.28  -- fix: cmd color
+            if old < parse_version("2.6.28"):
+                print("Migrating config from < 2.6.28...")
+                self.window.core.updater.patch_css('web-chatgpt.css', True)
+                self.window.core.updater.patch_css('web-chatgpt_wide.css', True)
+                self.window.core.updater.patch_css('web-chatgpt.dark.css', True)
+                self.window.core.updater.patch_css('web-chatgpt_wide.dark.css', True)
+                self.window.core.updater.patch_css('web-chatgpt.light.css', True)
+                self.window.core.updater.patch_css('web-chatgpt_wide.light.css', True)
+                updated = True
+
         # update file
         migrated = False
         if updated:

pygpt_net/ui/widget/tabs/output.py

@@ -323,6 +323,8 @@ class AddButton(QPushButton):
             idx = 0
             column_idx = self.column.get_idx()
             self.show_menu(idx, column_idx, event.globalPos())
+            event.accept()
+            return
         super(AddButton, self).mousePressEvent(event)
 
     def show_menu(self, index: int, column_idx: int, global_pos):

pygpt_net/ui/widget/textarea/input.py

@@ -30,6 +30,7 @@ class ChatInput(QTextEdit):
     ICON_VOLUME = QIcon(":/icons/volume.svg")
     ICON_SAVE = QIcon(":/icons/save.svg")
     ICON_ATTACHMENT = QIcon(":/icons/add.svg")
+    #ICON_ATTACHMENT = QIcon(":/icons/attachment.svg")
     ICON_MIC_ON = QIcon(":/icons/mic.svg")
     ICON_MIC_OFF = QIcon(":/icons/mic_off.svg")
 
@@ -46,7 +47,7 @@ class ChatInput(QTextEdit):
         self.value = self.window.core.config.data['font_size.input']
         self.max_font_size = 42
         self.min_font_size = 8
-        self._text_top_padding = 12
+        self._text_top_padding = 10
         self.textChanged.connect(self.window.controller.ui.update_tokens)
         self.setProperty('class', 'layout-input')
 
@@ -66,8 +67,8 @@ class ChatInput(QTextEdit):
         self._icon_meta = {}   # key -> {"icon": QIcon, "alt_icon": Optional[QIcon], "tooltip": str, "alt_tooltip": Optional[str], "active": bool}
         self._icon_order = []  # rendering order
 
-        # Add a "+" button in the top-left corner to add attachments
         self._init_icon_bar()
+        # Add a "+" button in the top-left corner to add attachments
         self.add_icon(
             key="attach",
             icon=self.ICON_ATTACHMENT,
@@ -75,6 +76,7 @@ class ChatInput(QTextEdit):
             callback=self.action_add_attachment,
             visible=True,
         )
+        # Add a microphone button (hidden by default; shown when audio input is enabled)
         self.add_icon(
             key="mic",
             icon=self.ICON_MIC_ON,
@@ -94,7 +96,11 @@ class ChatInput(QTextEdit):
         self._apply_margins()
 
     def set_text_top_padding(self, px: int):
-        """Public helper to adjust top padding at runtime."""
+        """
+        Public helper to adjust top padding at runtime.
+
+        :param px: padding in pixels
+        """
         self._text_top_padding = max(0, int(px))
         self._apply_margins()
 
@@ -177,9 +183,7 @@ class ChatInput(QTextEdit):
             menu.deleteLater()
 
     def action_from_clipboard(self):
-        """
-        Get from clipboard
-        """
+        """Paste from clipboard"""
         clipboard = QApplication.clipboard()
         source = clipboard.mimeData()
         self.handle_clipboard(source)
@@ -324,7 +328,6 @@ class ChatInput(QTextEdit):
                     pass
                 btn.clicked.connect(callback)
             btn.setHidden(not visible)
-            self._sync_icon_order(key)
             self._rebuild_icon_layout()
             self._update_icon_bar_geometry()
             self._apply_margins()

{pygpt_net-2.6.27.dist-info → pygpt_net-2.6.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pygpt-net
-Version: 2.6.27
+Version: 2.6.29
 Summary: Desktop AI Assistant powered by: OpenAI GPT-5, GPT-4, o1, o3, Gemini, Claude, Grok, DeepSeek, and other models supported by Llama Index, and Ollama. Chatbot, agents, completion, image generation, vision analysis, speech-to-text, plugins, internet access, file handling, command execution and more.
 License: MIT
 Keywords: ai,api,api key,app,assistant,bielik,chat,chatbot,chatgpt,claude,dall-e,deepseek,desktop,gemini,gpt,gpt-3.5,gpt-4,gpt-4-vision,gpt-4o,gpt-5,gpt-oss,gpt3.5,gpt4,grok,langchain,llama-index,llama3,mistral,o1,o3,ollama,openai,presets,py-gpt,py_gpt,pygpt,pyside,qt,text completion,tts,ui,vision,whisper
@@ -117,7 +117,7 @@ Description-Content-Type: text/markdown
 
 [![pygpt](https://snapcraft.io/pygpt/badge.svg)](https://snapcraft.io/pygpt)
 
-Release: **2.6.27** | build: **2025-08-26** | Python: **>=3.10, <3.14**
+Release: **2.6.29** | build: **2025-08-27** | Python: **>=3.10, <3.14**
 
 > Official website: https://pygpt.net | Documentation: https://pygpt.readthedocs.io
 > 
@@ -1470,12 +1470,16 @@ The following plugins are currently available, and model can use them instantly:
 
 - `Telegram` - Send messages, photos, and documents; manage chats and contacts.
 
+- `Tuya (IoT)` - Handle Tuya Smart Home devices via Tuya Cloud API.
+
 - `Vision (inline)` - integrates Vision capabilities with any chat mode, not just Vision mode. When the plugin is enabled, the model temporarily switches to vision in the background when an image attachment or vision capture is provided.
 
 - `Voice Control (inline)` - provides voice control command execution within a conversation.
 
 - `Web Search` - provides the ability to connect to the Web, search web pages for current data, and index external content using LlamaIndex data loaders.
 
+- `Wikipedia` - Search Wikipedia for information.
+
 - `X/Twitter` - Interact with tweets and users, manage bookmarks and media, perform likes, retweets, and more.
 
 
@@ -1862,6 +1866,20 @@ The plugin enables integration with Telegram for both bots and user accounts thr
 
 Documentation: https://pygpt.readthedocs.io/en/latest/plugins.html#telegram
 
+## Tuya (IoT)
+
+The Tuya plugin integrates with Tuya's Smart Home platform, enabling seamless interactions with your smart devices via the Tuya Cloud API. This plugin provides a user-friendly interface to manage and control devices directly from your assistant.
+
+* Provide your Tuya Cloud credentials to enable communication.
+* Access and list all smart devices connected to your Tuya app account.
+* Retrieve detailed information about each device, including its status and supported functions.
+* Effortlessly search for devices by their names using cached data for quick access.
+* Control devices by turning them on or off, toggle states, and set specific device parameters.
+* Send custom commands to devices for more advanced control.
+* Read sensor values and normalize them for easy interpretation.
+
+Documentation: https://pygpt.readthedocs.io/en/latest/plugins.html#tuya-iot
+
 ## Vision (inline)
 
 The plugin integrates vision capabilities across all chat modes, not just Vision mode. Once enabled, it allows the model to seamlessly switch to vision processing in the background whenever an image attachment or vision capture is detected.
@@ -1886,6 +1904,20 @@ Web searches are provided by `Google Custom Search Engine` and `Microsoft Bing`
 
 Documentation: https://pygpt.readthedocs.io/en/latest/plugins.html#web-search
 
+## Wikipedia
+
+The Wikipedia plugin allows for comprehensive interactions with Wikipedia, including language settings, article searching, summaries, and random article discovery. This plugin offers a variety of options to optimize your search experience.
+
+* Set your preferred language for Wikipedia queries.
+* Retrieve and check the current language setting.
+* Explore a list of supported languages.
+* Search for articles using keywords or get suggestions for queries.
+* Obtain summaries and detailed page content.
+* Discover articles by geographic location or randomly.
+* Open articles directly in your web browser.
+
+Documentation: https://pygpt.readthedocs.io/en/latest/plugins.html#wikipedia
+
 ## X/Twitter
 
 The X/Twitter plugin integrates with the X platform, allowing for comprehensive interactions such as tweeting, retweeting, liking, media uploads, and more. This plugin requires OAuth2 authentication and offers various configuration options to manage API interactions effectively.
@@ -2331,8 +2363,6 @@ Config -> Settings...
 
 - `Directory for file downloads`: Subdirectory for downloaded files, e.g. in Assistants mode, inside "data". Default: "download"
 
-- `Verbose mode`: Enabled verbose mode when using attachment as additional context.
-
 - `Model for querying index`: Model to use for preparing query and querying the index when the RAG option is selected.
 
 - `Model for attachment content summary`: Model to use when generating a summary for the content of a file when the Summary option is selected.
@@ -2537,8 +2567,6 @@ Enable/disable remote tools, like Web Search or Image generation to use in OpenA
 
 **General**
 
-- `Verbose` - enables verbose mode.
-
 - `Auto retrieve additional context from RAG`: Auto retrieve additional context from RAG at the beginning if the index is provided.
 
 - `Display a tray notification when the goal is achieved.`: If enabled, a notification will be displayed after goal achieved / finished run.
@@ -2621,6 +2649,10 @@ Enable/disable remote tools, like Web Search or Image generation to use in OpenA
 
 - `Log DALL-E usage to console`: Enables logging of DALL-E usage to console.
 
+- `Log attachments usage to console`: Enables logging of attachments usage to console.
+
+- `Log Agents usage to console`: Enables logging of Agents usage to console.
+
 - `Log LlamaIndex usage to console`: Enables logging of LlamaIndex usage to console.
 
 - `Log Assistants usage to console`: Enables logging of Assistants API usage to console.
@@ -3543,6 +3575,18 @@ may consume additional tokens that are not displayed in the main window.
 
 ## Recent changes:
 
+**2.6.29 (2025-08-28)**
+
+- Verbose options have been moved to the Developer section in settings.
+- Enhanced logging of embeddings usage.
+- Fixed styles list.
+
+**2.6.28 (2025-08-27)**
+
+- Added new plugins: Tuya (IoT) and Wikipedia.
+- Improved formatting of JSON command output.
+- Fixed CSS issues.
+
 **2.6.27 (2025-08-26)**
 
 - Simplified audio input: A microphone icon has been added to the input field.