GameSentenceMiner 2.8.6__tar.gz → 2.8.8__tar.gz

gamesentenceminer-2.8.8/GameSentenceMiner/ai/ai_prompting.py

@@ -0,0 +1,201 @@
+import logging
+import textwrap
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Any, Optional
+
+import google.generativeai as genai
+from groq import Groq
+
+from GameSentenceMiner.configuration import get_config, Ai, logger
+from GameSentenceMiner.text_log import GameLine
+
+# Suppress debug logs from httpcore
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("groq._base_client").setLevel(logging.WARNING)
+
+
+TRANSLATION_PROMPT = textwrap.dedent(f"""Translate the following Japanese dialogue from this game into natural, context-aware English. Focus on preserving the tone, intent, and emotional nuance of the original text, paying close attention to the context provided by surrounding lines. The dialogue may include slang, idioms, implied meanings, or game-specific terminology that should be adapted naturally for English-speaking players. Ensure the translation feels immersive and aligns with the game's narrative style and character voices.
+                                    Translate only the specified line below, providing a single result. Do not include additional text, explanations, alternatives, or other lines unless explicitly requested. If there are alternatives, choose the best one. Allow expletives if more natural. Allow HTML tags for emphasis, italics, and other formatting as needed. Please also try to preserve existing HTML tags from the specified sentence if appropriate. Answer with nothing but the best translation, no alternatives or explanations.
+
+                                    Line to Translate:
+""")
+
+CONTEXT_PROMPT = textwrap.dedent(f"""Provide a very brief summary of the scene in English based on the provided Japanese dialogue and context. Focus on the characters' actions and the immediate situation being described.
+
+                                    Current Sentence:
+""")
+
+class AIType(Enum):
+    GEMINI = "Gemini"
+    GROQ = "Groq"
+
+@dataclass
+class AIConfig:
+    api_key: str
+    model: str
+    api_url: Optional[str]
+    type: 'AIType'
+
+@dataclass
+class GeminiAIConfig(AIConfig):
+    def __init__(self, api_key: str, model: str = "gemini-2.0-flash"):
+        super().__init__(api_key=api_key, model=model, api_url=None, type=AIType.GEMINI)
+
+@dataclass
+class GroqAiConfig(AIConfig):
+    def __init__(self, api_key: str, model: str = "meta-llama/llama-4-scout-17b-16e-instruct"):
+        super().__init__(api_key=api_key, model=model, api_url=None, type=AIType.GROQ)
+
+
+class AIManager(ABC):
+    def __init__(self, ai_config: AIConfig, logger: Optional[logging.Logger] = None):
+        self.ai_config = ai_config
+        self.logger = logger
+
+    @abstractmethod
+    def process(self, lines: List[GameLine], sentence: str, current_line_index: int, game_title: str = "") -> str:
+        pass
+
+    @abstractmethod
+    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str) -> str:
+        start_index = max(0, current_line.index - 10)
+        end_index = min(len(lines), current_line.index + 11)
+
+        context_lines_text = []
+        for i in range(start_index, end_index):
+            if i < len(lines):
+                context_lines_text.append(lines[i].text)
+
+        dialogue_context = "\n".join(context_lines_text)
+
+        if get_config().ai.use_canned_translation_prompt:
+            prompt_to_use = TRANSLATION_PROMPT
+        elif get_config().ai.use_canned_context_prompt:
+            prompt_to_use = CONTEXT_PROMPT
+        else:
+            prompt_to_use = getattr(self.ai_config, 'custom_prompt', "")
+
+        full_prompt = textwrap.dedent(f"""
+            Dialogue Context:
+
+            {dialogue_context}
+
+            I am playing the game {game_title}. With that, and the above dialogue context in mind, answer the following prompt.
+
+            {prompt_to_use}
+
+            {sentence}
+        """)
+        return full_prompt
+
+
+class GeminiAI(AIManager):
+    def __init__(self, model, api_key, logger: Optional[logging.Logger] = None):
+        super().__init__(GeminiAIConfig(model=model, api_key=api_key), logger)
+        try:
+            genai.configure(api_key=self.ai_config.api_key)
+            model_name = self.ai_config.model
+            self.model = genai.GenerativeModel(model_name)
+            self.logger.info(f"GeminiAIManager initialized with model: {model_name}")
+        except Exception as e:
+            self.logger.error(f"Failed to initialize Gemini API: {e}")
+            self.model = None
+
+    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str) -> str:
+        prompt = super()._build_prompt(lines, sentence, current_line, game_title)
+        return prompt
+
+    def process(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "") -> str:
+        if self.model is None:
+            return "Processing failed: AI model not initialized."
+
+        if not lines or not current_line:
+            self.logger.warning(f"Invalid input for process: lines={len(lines)}, current_line={current_line.index}")
+            return "Invalid input."
+
+        try:
+            prompt = self._build_prompt(lines, sentence, current_line, game_title)
+            self.logger.debug(f"Generated prompt:\n{prompt}")
+            response = self.model.generate_content(prompt)
+            result = response.text.strip()
+            self.logger.debug(f"Received response:\n{result}")
+            return result
+        except Exception as e:
+            self.logger.error(f"Gemini processing failed: {e}")
+            return f"Processing failed: {e}"
+
+class GroqAI(AIManager):
+    def __init__(self, model, api_key, logger: Optional[logging.Logger] = None):
+        super().__init__(GroqAiConfig(model=model, api_key=api_key), logger)
+        self.api_key = self.ai_config.api_key
+        self.model_name = self.ai_config.model
+        try:
+            self.client = Groq(api_key=self.api_key)
+            self.logger.info(f"GroqAIManager initialized with model: {self.model_name}")
+        except Exception as e:
+            self.logger.error(f"Failed to initialize Groq client: {e}")
+            self.client = None
+
+    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str) -> str:
+        prompt = super()._build_prompt(lines, sentence, current_line, game_title)
+        return prompt
+
+    def process(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "") -> str:
+        if self.client is None:
+            return "Processing failed: Groq client not initialized."
+
+        if not lines or not current_line:
+            self.logger.warning(f"Invalid input for process: lines={len(lines)}, current_line={current_line.index}")
+            return "Invalid input."
+
+        try:
+            prompt = self._build_prompt(lines, sentence, current_line, game_title)
+            self.logger.debug(f"Generated prompt:\n{prompt}")
+            completion = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=.5,
+                max_completion_tokens=1024,
+                top_p=1,
+                stream=False,
+                stop=None,
+            )
+            result = completion.choices[0].message.content.strip()
+            self.logger.debug(f"Received response:\n{result}")
+            return result
+        except Exception as e:
+            self.logger.error(f"Groq processing failed: {e}")
+            return f"Processing failed: {e}"
+
+ai_manager: AIManager | None = None
+current_ai_config: Ai | None = None
+
+def get_ai_prompt_result(lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = ""):
+    global ai_manager, current_ai_config
+    if not ai_manager or get_config().ai != current_ai_config:
+        if get_config().ai.provider == AIType.GEMINI.value:
+            ai_manager = GeminiAI(model=get_config().ai.gemini_model, api_key=get_config().ai.gemini_api_key, logger=logger)
+        elif get_config().ai.provider == AIType.GROQ.value:
+            ai_manager = GroqAI(model=get_config().ai.groq_model, api_key=get_config().ai.groq_api_key, logger=logger)
+        current_ai_config = get_config().ai
+    return ai_manager.process(lines, sentence, current_line, game_title)
+
+if __name__ == '__main__':
+    lines = [
+        GameLine(index=0, text="こんにちは、元気ですか？", id=None, time=None, prev=None, next=None),
+        GameLine(index=1, text="今日はいい天気ですね。",id=None, time=None, prev=None, next=None),
+        GameLine(index=2, text="ゲームを始めましょう！",id=None, time=None, prev=None, next=None),
+    ]
+    sentence = "ゲームを始めましょう！"
+    current_line = lines[2]
+    game_title = "Test Game"
+
+    # Set up logging
+    logging.basicConfig(level=logging.DEBUG)
+
+    # Test the function
+    result = get_ai_prompt_result(lines, sentence, current_line, game_title)
+    print("AI Prompt Result:", result)

{gamesentenceminer-2.8.6 → gamesentenceminer-2.8.8}/GameSentenceMiner/anki.py

@@ -8,7 +8,7 @@ from datetime import datetime, timedelta
 from requests import post
 
 from GameSentenceMiner import obs, util, notification, ffmpeg
-from GameSentenceMiner.ai.gemini import translate_with_context
+from GameSentenceMiner.ai.ai_prompting import GeminiAI, get_ai_prompt_result
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.configuration import get_config
 from GameSentenceMiner.model import AnkiCard
@@ -67,8 +67,8 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
         sentence_field = note['fields'].get(get_config().anki.sentence_field, {})
         sentence_to_translate = sentence_field if sentence_field else last_note.get_field(
             get_config().anki.sentence_field)
-        translation = translate_with_context(get_all_lines(), sentence_to_translate,
-                                                                   game_line.index, get_current_game())
+        translation = get_ai_prompt_result(get_all_lines(), sentence_to_translate,
+                                 game_line, get_current_game())
         logger.info(translation)
         note['fields'][get_config().ai.anki_field] = translation
 
@@ -286,6 +286,7 @@ def update_new_card():
         try:
             obs.save_replay_buffer()
         except Exception as e:
+            card_queue.pop(0)
             logger.error(f"Error saving replay buffer: {e}")
             return
 

{gamesentenceminer-2.8.6 → gamesentenceminer-2.8.8}/GameSentenceMiner/config_gui.py

@@ -206,9 +206,12 @@ class ConfigApp:
             ),
             ai=Ai(
                 enabled=self.ai_enabled.get(),
-                # provider=self.provider.get(),
+                provider=self.ai_provider.get(),
+                gemini_model=self.gemini_model.get(),
+                groq_model=self.groq_model.get(),
+                gemini_api_key=self.gemini_api_key.get(),
+                groq_api_key=self.groq_api_key.get(),
                 anki_field=self.ai_anki_field.get(),
-                api_key=self.ai_api_key.get(),
                 use_canned_translation_prompt=self.use_canned_translation_prompt.get(),
                 use_canned_context_prompt=self.use_canned_context_prompt.get(),
                 custom_prompt=self.custom_prompt.get("1.0", tk.END)
@@ -1004,12 +1007,18 @@ class ConfigApp:
         ttk.Checkbutton(ai_frame, variable=self.ai_enabled).grid(row=self.current_row, column=1, sticky='W')
         self.add_label_and_increment_row(ai_frame, "Enable or disable AI integration.", row=self.current_row, column=2)
 
-        ttk.Label(ai_frame, text="Anki Field:").grid(row=self.current_row, column=0, sticky='W')
-        self.ai_anki_field = ttk.Entry(ai_frame)
-        self.ai_anki_field.insert(0, self.settings.ai.anki_field)
-        self.ai_anki_field.grid(row=self.current_row, column=1)
-        self.add_label_and_increment_row(ai_frame, "Field in Anki for AI-generated content.", row=self.current_row,
-                                         column=2)
+        ttk.Label(ai_frame, text="Provider:").grid(row=self.current_row, column=0, sticky='W')
+        self.ai_provider = ttk.Combobox(ai_frame, values=['Gemini', 'Groq'])
+        self.ai_provider.set(self.settings.ai.provider)
+        self.ai_provider.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(ai_frame, "Select the AI provider.", row=self.current_row, column=2)
+
+        ttk.Label(ai_frame, text="Gemini AI Model:").grid(row=self.current_row, column=0, sticky='W')
+        self.gemini_model = ttk.Combobox(ai_frame, values=['gemini-2.0-flash', 'gemini-2.0-flash-lite', 'gemini-2.5-pro-preview-03-25', 'gemini-2.5-flash-preview-04-17'])
+        self.gemini_model.set(self.settings.ai.gemini_model)
+        self.gemini_model.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(ai_frame, "Select the AI model to use.", row=self.current_row, column=2)
+
 
         # ttk.Label(ai_frame, text="Provider:").grid(row=self.current_row, column=0, sticky='W')
         # self.provider = ttk.Combobox(ai_frame,
@@ -1018,13 +1027,34 @@ class ConfigApp:
         # self.provider.grid(row=self.current_row, column=1)
         # self.add_label_and_increment_row(ai_frame, "Select the AI provider. Currently only Gemini is supported.", row=self.current_row, column=2)
 
-        ttk.Label(ai_frame, text="API Key:").grid(row=self.current_row, column=0, sticky='W')
-        self.ai_api_key = ttk.Entry(ai_frame, show="*")  # Mask the API key for security
-        self.ai_api_key.insert(0, self.settings.ai.api_key)
-        self.ai_api_key.grid(row=self.current_row, column=1)
+        ttk.Label(ai_frame, text="Gemini API Key:").grid(row=self.current_row, column=0, sticky='W')
+        self.gemini_api_key = ttk.Entry(ai_frame, show="*")  # Mask the API key for security
+        self.gemini_api_key.insert(0, self.settings.ai.gemini_api_key)
+        self.gemini_api_key.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(ai_frame, "API key for the selected AI provider (Gemini only currently).", row=self.current_row,
                                          column=2)
 
+        ttk.Label(ai_frame, text="Groq AI Model:").grid(row=self.current_row, column=0, sticky='W')
+        self.groq_model = ttk.Combobox(ai_frame, values=['meta-llama/llama-4-maverick-17b-128e-instruct', 'meta-llama/llama-4-scout-17b-16e-instruct', 'llama-3.1-8b-instant'])
+        self.groq_model.set(self.settings.ai.groq_model)
+        self.groq_model.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(ai_frame, "Select the Groq AI model to use.", row=self.current_row, column=2)
+
+
+        ttk.Label(ai_frame, text="Groq API Key:").grid(row=self.current_row, column=0, sticky='W')
+        self.groq_api_key = ttk.Entry(ai_frame, show="*")  # Mask the API key for security
+        self.groq_api_key.insert(0, self.settings.ai.groq_api_key)
+        self.groq_api_key.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(ai_frame, "API key for Groq AI provider.", row=self.current_row,
+                                            column=2)
+
+        ttk.Label(ai_frame, text="Anki Field:").grid(row=self.current_row, column=0, sticky='W')
+        self.ai_anki_field = ttk.Entry(ai_frame)
+        self.ai_anki_field.insert(0, self.settings.ai.anki_field)
+        self.ai_anki_field.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(ai_frame, "Field in Anki for AI-generated content.", row=self.current_row,
+                                         column=2)
+
         ttk.Label(ai_frame, text="Use Canned Translation Prompt:").grid(row=self.current_row, column=0, sticky='W')
         self.use_canned_translation_prompt = tk.BooleanVar(value=self.settings.ai.use_canned_translation_prompt)
         ttk.Checkbutton(ai_frame, variable=self.use_canned_translation_prompt).grid(row=self.current_row, column=1,

{gamesentenceminer-2.8.6 → gamesentenceminer-2.8.8}/GameSentenceMiner/configuration.py

@@ -28,7 +28,8 @@ WHISPER_SMALL = 'small'
 WHISPER_MEDIUM = 'medium'
 WHSIPER_LARGE = 'large'
 
-AI_GEMINI = 'gemini'
+AI_GEMINI = 'Gemini'
+AI_GROQ = 'Groq'
 
 INFO = 'INFO'
 DEBUG = 'DEBUG'
@@ -134,7 +135,7 @@ class OBS:
     open_obs: bool = True
     close_obs: bool = True
     host: str = "127.0.0.1"
-    port: int = 4455
+    port: int = 7274
     password: str = "your_password"
     get_game_from_scene: bool = True
     minimum_replay_size: int = 0
@@ -187,11 +188,18 @@ class Ai:
     enabled: bool = False
     anki_field: str = ''
     provider: str = AI_GEMINI
-    api_key: str = ''
+    gemini_model: str = 'gemini-2.0-flash'
+    groq_model: str = 'meta-llama/llama-4-scout-17b-16e-instruct'
+    api_key: str = '' # Deprecated
+    gemini_api_key: str = ''
+    groq_api_key: str = ''
     use_canned_translation_prompt: bool = True
     use_canned_context_prompt: bool = False
     custom_prompt: str = ''
 
+    def __post_init__(self):
+        self.gemini_api_key = self.api_key
+
 
 @dataclass_json
 @dataclass
@@ -306,6 +314,21 @@ class Config:
         instance = cls(configs={DEFAULT_CONFIG: ProfileConfig()}, current_profile=DEFAULT_CONFIG)
         return instance
 
+    @classmethod
+    def load(cls):
+        config_path = get_config_path()
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as file:
+                data = json.load(file)
+                return cls.from_dict(data)
+        else:
+            return cls.new()
+
+    def save(self):
+        with open(get_config_path(), 'w') as file:
+            json.dump(self.to_dict(), file, indent=4)
+        return self
+
     def get_config(self) -> ProfileConfig:
         return self.configs[self.current_profile]
 
@@ -355,7 +378,8 @@ class Config:
             self.sync_shared_field(config.ai, profile.ai, "anki_field")
             self.sync_shared_field(config.ai, profile.ai, "provider")
             self.sync_shared_field(config.ai, profile.ai, "api_key")
-
+            self.sync_shared_field(config.ai, profile.ai, "gemini_api_key")
+            self.sync_shared_field(config.ai, profile.ai, "groq_api_key")
 
         return self
 
@@ -513,22 +537,22 @@ sys.stderr.reconfigure(encoding='utf-8')
 
 logger = logging.getLogger("GameSentenceMiner")
 logger.setLevel(logging.DEBUG)  # Set the base level to DEBUG so that all messages are captured
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 
 # Create console handler with level INFO
 console_handler = logging.StreamHandler(sys.stdout)
 console_handler.setLevel(logging.INFO)
 
-# Create rotating file handler with level DEBUG
-file_handler = RotatingFileHandler(get_log_path(), maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
-file_handler.setLevel(logging.DEBUG)
-
-# Create a formatter
-formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-
-# Add formatter to handlers
 console_handler.setFormatter(formatter)
-file_handler.setFormatter(formatter)
 
-# Add handlers to the logger
 logger.addHandler(console_handler)
-logger.addHandler(file_handler)
+
+# Create rotating file handler with level DEBUG
+if 'gsm' in sys.argv[0]:
+    file_handler = RotatingFileHandler(get_log_path(), maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+
+DB_PATH = os.path.join(get_app_directory(), 'gsm.db')
+

{gamesentenceminer-2.8.6 → gamesentenceminer-2.8.8}/GameSentenceMiner/gametext.py

@@ -1,7 +1,5 @@
 import asyncio
 import re
-import threading
-import time
 
 import pyperclip
 import websockets
@@ -24,31 +22,23 @@ websocket_connected = False
     # def remove_old_events(self, cutoff_time: datetime):
     #     self.values = [line for line in self.values if line.time >= cutoff_time]
 
-class ClipboardMonitor(threading.Thread):
+async def monitor_clipboard():
+    # Initial clipboard content
+    current_clipboard = pyperclip.paste()
 
-    def __init__(self):
-        threading.Thread.__init__(self)
-        self.daemon = True
-
-    def run(self):
-        global current_line_time, current_line
-
-        # Initial clipboard content
-        current_line = pyperclip.paste()
-
-        skip_next_clipboard = False
-        while True:
-            if not get_config().general.use_both_clipboard_and_websocket and websocket_connected:
-                time.sleep(1)
-                skip_next_clipboard = True
-                continue
-            current_clipboard = pyperclip.paste()
+    skip_next_clipboard = False
+    while True:
+        if not get_config().general.use_both_clipboard_and_websocket and websocket_connected:
+            await asyncio.sleep(1)
+            skip_next_clipboard = True
+            continue
+        current_clipboard = pyperclip.paste()
 
-            if current_clipboard != current_line and not skip_next_clipboard:
-                handle_new_text_event(current_clipboard)
-                skip_next_clipboard = False
+        if current_clipboard and current_clipboard != current_line and not skip_next_clipboard:
+            await handle_new_text_event(current_clipboard)
+            skip_next_clipboard = False
 
-            time.sleep(0.05)
+        await asyncio.sleep(0.05)
 
 
 async def listen_websocket():
@@ -69,6 +59,8 @@ async def listen_websocket():
                 line_time = None
                 while True:
                     message = await websocket.recv()
+                    if not message:
+                        continue
                     logger.debug(message)
                     try:
                         data = json.loads(message)
@@ -76,26 +68,25 @@ async def listen_websocket():
                             current_clipboard = data["sentence"]
                         if "time" in data:
                             line_time = datetime.fromisoformat(data["time"])
-                            print(line_time)
                     except json.JSONDecodeError or TypeError:
                         current_clipboard = message
                     if current_clipboard != current_line:
-                        handle_new_text_event(current_clipboard, line_time if line_time else None)
-        except (websockets.ConnectionClosed, ConnectionError, InvalidStatus) as e:
+                        await handle_new_text_event(current_clipboard, line_time if line_time else None)
+        except (websockets.ConnectionClosed, ConnectionError, InvalidStatus, ConnectionResetError, Exception) as e:
             if isinstance(e, InvalidStatus):
                 e: InvalidStatus
                 if e.response.status_code == 404:
                     logger.info("Texthooker WebSocket connection failed. Attempting some fixes...")
                     try_other = True
-
-                logger.error(f"Texthooker WebSocket connection failed. Please check if the Texthooker is running and the WebSocket URI is correct.")
+            if not (isinstance(e, ConnectionResetError) or isinstance(e, ConnectionError) or isinstance(e, InvalidStatus) or isinstance(e, websockets.ConnectionClosed)):
+                logger.error(f"Unexpected error in Texthooker WebSocket connection: {e}")
             websocket_connected = False
             if not reconnecting:
                 logger.warning(f"Texthooker WebSocket connection lost, Defaulting to clipboard if enabled. Attempting to Reconnect...")
             reconnecting = True
             await asyncio.sleep(5)
 
-def handle_new_text_event(current_clipboard, line_time=None):
+async def handle_new_text_event(current_clipboard, line_time=None):
     global current_line, current_line_time, current_line_after_regex
     current_line = current_clipboard
     if get_config().general.texthook_replacement_regex:
@@ -106,7 +97,7 @@ def handle_new_text_event(current_clipboard, line_time=None):
     logger.info(f"Line Received: {current_line_after_regex}")
     current_line_time = line_time if line_time else datetime.now()
     add_line(current_line_after_regex, line_time)
-    add_event_to_texthooker(get_text_log()[-1])
+    await add_event_to_texthooker(get_text_log()[-1])
 
 def reset_line_hotkey_pressed():
     global current_line_time
@@ -119,13 +110,14 @@ def run_websocket_listener():
     asyncio.run(listen_websocket())
 
 
-def start_text_monitor():
+async def start_text_monitor():
     if get_config().general.use_websocket:
-        threading.Thread(target=run_websocket_listener, daemon=True).start()
+        util.run_new_thread(run_websocket_listener)
     if get_config().general.use_clipboard:
         if get_config().general.use_websocket:
             if get_config().general.use_both_clipboard_and_websocket:
                 logger.info("Listening for Text on both WebSocket and Clipboard.")
             else:
                 logger.info("Both WebSocket and Clipboard monitoring are enabled. WebSocket will take precedence if connected.")
-        ClipboardMonitor().start()
+        await monitor_clipboard()
+    await asyncio.sleep(1)