agentcrew-ai 0.8.10__tar.gz → 0.8.12__tar.gz

agentcrew_ai-0.8.12/AgentCrew/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.12"

{agentcrew_ai-0.8.10 → agentcrew_ai-0.8.12}/AgentCrew/app.py

@@ -265,7 +265,8 @@ class AgentCrewApplication:
             search_service = None
 
         try:
-            code_analysis_service = CodeAnalysisService()
+            code_analysis_llm = llm_manager.initialize_standalone_service(provider)
+            code_analysis_service = CodeAnalysisService(llm_service=code_analysis_llm)
         except Exception as e:
             click.echo(f"⚠️ Code analysis tool not available: {str(e)}")
             code_analysis_service = None

{agentcrew_ai-0.8.10 → agentcrew_ai-0.8.12}/AgentCrew/main.py

@@ -7,6 +7,20 @@ import platform
 from AgentCrew.app import common_options
 
 
+def _custom_unraisable_hook(unraisable):
+    """Suppress httpcore async cleanup exceptions when streams are cancelled."""
+    exc_type = unraisable.exc_type
+    exc_value = unraisable.exc_value
+    if exc_type and exc_type.__name__ == "AsyncLibraryNotFoundError":
+        return
+    if exc_value and "httpcore" in str(type(exc_value).__module__):
+        return
+    sys.__unraisablehook__(unraisable)
+
+
+sys.unraisablehook = _custom_unraisable_hook
+
+
 PROVIDER_LIST = [
     "claude",
     "groq",

{agentcrew_ai-0.8.10 → agentcrew_ai-0.8.12}/AgentCrew/main_docker.py

@@ -3,6 +3,20 @@ import os
 import sys
 
 
+def _custom_unraisable_hook(unraisable):
+    """Suppress httpcore async cleanup exceptions when streams are cancelled."""
+    exc_type = unraisable.exc_type
+    exc_value = unraisable.exc_value
+    if exc_type and exc_type.__name__ == "AsyncLibraryNotFoundError":
+        return
+    if exc_value and "httpcore" in str(type(exc_value).__module__):
+        return
+    sys.__unraisablehook__(unraisable)
+
+
+sys.unraisablehook = _custom_unraisable_hook
+
+
 PROVIDER_LIST = [
     "claude",
     "groq",

{agentcrew_ai-0.8.10 → agentcrew_ai-0.8.12}/AgentCrew/modules/agents/local_agent.py

@@ -584,13 +584,19 @@ You must analyze then execute it with your available tools and give answer witho
                     for key, value in local_adaptive_behaviors.items()
                 ]
             )
+        adaptive_text.extend(
+            [
+                "<Global_Behavior id='transfer'>When working on my request, consider whether if any other agents is more suitable, if yes, transfer to that agent.</Global_Behavior>",
+                "<Global_Behavior id='default'>When encountering tasks that you have no data in the context and you don't know the anwser, say I don't know and ask user for helping you find the solution.</Global_Behavior>",
+            ]
+        )
         if len(adaptive_text) > 0:
             adaptive_messages["content"].append(
                 {
                     "type": "text",
-                    "text": f"""<MANDATORY>APPLY list of <Adaptive_Behaviors> before responding. 
-Check if `when` condition in <Global_Behavior> or <Project_Behavior> matches, update your responses with behaviors immediately—they override default instruction.
-<Project_Behavior> has higher priority than <Global_Behavior>.</MANDATORY>
+                    "text": f"""Read through all behaviors in the <Adaptive_Behaviors> tags before generating responses. 
+Whenever condition on `when` clause in a **Behavior** matches, tailor your responses with that **Behavior** immediately, override default instruction.
+<Project_Behavior> has higher priority than <Global_Behavior>.
 <Adaptive_Behaviors>
 {"  \n".join(adaptive_text)}
 </Adaptive_Behaviors>""",
@@ -618,6 +624,17 @@ Check if `when` condition in <Global_Behavior> or <Project_Behavior> matches, up
             .find("<Transfer_Tool>")
             != 0
         ):
+            if not self.is_remoting_mode and self.services.get("memory"):
+                memory_headers = self.services["memory"].list_memory_headers(
+                    agent_name=self.name
+                )
+                if memory_headers:
+                    adaptive_messages["content"].append(
+                        {
+                            "type": "text",
+                            "text": f"Belows are our last 20 discussion headlines:\n - {'\n - '.join(memory_headers)}",
+                        }
+                    )
             if (
                 self.services.get("agent_manager")
                 and self.services["agent_manager"].enforce_transfer
@@ -627,24 +644,13 @@ Check if `when` condition in <Global_Behavior> or <Project_Behavior> matches, up
                     {
                         "type": "text",
                         "text": """Before processing my request:
-    - Break my request into sub-tasks when applicable.
-    - For each sub-task, evaluate other agents capabilities.
-    - Transfer sub-task to other agent if they are more suitable. 
-    - Keep the evaluating quick and concise using xml format within <agent_evaluation> tags.
-    - Skip agent evaluation if user request is when...,[action]... related to adaptive behaviors call `adapt` tool instead.""",
+            - Break my request into actionable sub-tasks when applicable.
+            - For each sub-task, evaluate your tools and plan tool strategy for acquiring the context you need for the main task.
+            - Action subsequent steps base on your plan.
+            - Keep the evaluating quick and concise using xml format within <agent_evaluation> tags.
+            - Skip agent evaluation if user request is when...,[action]... related to adaptive behaviors call `adapt` tool instead.""",
                     },
                 )
-            if not self.is_remoting_mode and self.services.get("memory"):
-                memory_headers = self.services["memory"].list_memory_headers(
-                    agent_name=self.name
-                )
-                if memory_headers:
-                    adaptive_messages["content"].append(
-                        {
-                            "type": "text",
-                            "text": f"Here are conversations that we have discussed from oldest to latest:\n - {'\n - '.join(memory_headers)}",
-                        }
-                    )
         if len(adaptive_messages["content"]) > 0:
             final_messages.insert(last_user_index, adaptive_messages)
 
@@ -665,7 +671,7 @@ Check if `when` condition in <Global_Behavior> or <Project_Behavior> matches, up
                     "content": [
                         {
                             "type": "text",
-                            "text": f"""<Transfer_Reminder>Make sure to transfer after the task is completed: {agent_manager.defered_transfer}</Transfer_Reminder>""",
+                            "text": f"""<Transfer_Reminder>Make sure to transfer the task result after the task is completed to {agent_manager.defered_transfer}</Transfer_Reminder>""",
                         }
                     ],
                 },
@@ -713,19 +719,20 @@ Check if `when` condition in <Global_Behavior> or <Project_Behavior> matches, up
             elif msg.get("role") == "tool":
                 tool_name = msg.get("tool_name", "")
 
-                # Remove denied tools after agent correct it
-                if msg.get("is_rejected", False):
-                    has_last_user_message = next(
-                        (True for _ in final_messages[i:] if msg.get("role") == "user"),
-                        False,
-                    )
-                    if has_last_user_message:
-                        tool_id = msg.get("tool_call_id", "")
-                        last_assistant_msg = final_messages[i - 1]
-                        for tool_call in last_assistant_msg.get("tool_calls", []):
-                            if tool_call.get("id", "") == tool_id:
-                                tool_call["arguments"] = {}
-                                break
+                # TODO: this will be failed if agent call tool in parallel
+                # # Remove denied tools after agent correct it
+                # if msg.get("is_rejected", False):
+                #     has_last_user_message = next(
+                #         (True for _ in final_messages[i:] if msg.get("role") == "user"),
+                #         False,
+                #     )
+                #     if has_last_user_message:
+                #         tool_id = msg.get("tool_call_id", "")
+                #         last_assistant_msg = final_messages[i - 1]
+                #         for tool_call in last_assistant_msg.get("tool_calls", []):
+                #             if tool_call.get("id", "") == tool_id:
+                #                 tool_call["arguments"] = {}
+                #                 break
 
                 if tool_name in shrink_excluded:
                     continue

{agentcrew_ai-0.8.10 → agentcrew_ai-0.8.12}/AgentCrew/modules/browser_automation/js_loader.py

@@ -254,17 +254,114 @@ class JavaScriptExecutor:
             logger.error(f"Error during typing simulation: {e}")
             return {"success": False, "error": f"Typing simulation failed: {str(e)}"}
 
+    @staticmethod
+    def _get_key_definition(key: str) -> Optional[Dict[str, Any]]:
+        """
+        Get key definition for a given key.
+        Handles both predefined special keys and dynamic alphanumeric keys.
+        """
+        key_name = key.lower().strip()
+
+        if key_name in key_definitions:
+            return key_definitions[key_name]
+
+        if len(key) == 1:
+            char = key
+            char_lower = char.lower()
+            char_upper = char.upper()
+
+            if char_lower.isalpha():
+                key_code = ord(char_upper)
+                return {
+                    "keyCode": key_code,
+                    "key": char_lower,
+                    "code": f"Key{char_upper}",
+                    "text": char_lower,
+                }
+            elif char.isdigit():
+                key_code = ord(char)
+                return {
+                    "keyCode": key_code,
+                    "key": char,
+                    "code": f"Digit{char}",
+                    "text": char,
+                }
+            else:
+                symbol_map = {
+                    "`": {"keyCode": 192, "code": "Backquote", "key": "`", "text": "`"},
+                    "-": {"keyCode": 189, "code": "Minus", "key": "-", "text": "-"},
+                    "=": {"keyCode": 187, "code": "Equal", "key": "=", "text": "="},
+                    "[": {
+                        "keyCode": 219,
+                        "code": "BracketLeft",
+                        "key": "[",
+                        "text": "[",
+                    },
+                    "]": {
+                        "keyCode": 221,
+                        "code": "BracketRight",
+                        "key": "]",
+                        "text": "]",
+                    },
+                    "\\": {
+                        "keyCode": 220,
+                        "code": "Backslash",
+                        "key": "\\",
+                        "text": "\\",
+                    },
+                    ";": {"keyCode": 186, "code": "Semicolon", "key": ";", "text": ";"},
+                    "'": {"keyCode": 222, "code": "Quote", "key": "'", "text": "'"},
+                    ",": {"keyCode": 188, "code": "Comma", "key": ",", "text": ","},
+                    ".": {"keyCode": 190, "code": "Period", "key": ".", "text": "."},
+                    "/": {"keyCode": 191, "code": "Slash", "key": "/", "text": "/"},
+                    "~": {"keyCode": 192, "code": "Backquote", "key": "~", "text": "~"},
+                    "!": {"keyCode": 49, "code": "Digit1", "key": "!", "text": "!"},
+                    "@": {"keyCode": 50, "code": "Digit2", "key": "@", "text": "@"},
+                    "#": {"keyCode": 51, "code": "Digit3", "key": "#", "text": "#"},
+                    "$": {"keyCode": 52, "code": "Digit4", "key": "$", "text": "$"},
+                    "%": {"keyCode": 53, "code": "Digit5", "key": "%", "text": "%"},
+                    "^": {"keyCode": 54, "code": "Digit6", "key": "^", "text": "^"},
+                    "&": {"keyCode": 55, "code": "Digit7", "key": "&", "text": "&"},
+                    "*": {"keyCode": 56, "code": "Digit8", "key": "*", "text": "*"},
+                    "(": {"keyCode": 57, "code": "Digit9", "key": "(", "text": "("},
+                    ")": {"keyCode": 48, "code": "Digit0", "key": ")", "text": ")"},
+                    "_": {"keyCode": 189, "code": "Minus", "key": "_", "text": "_"},
+                    "+": {"keyCode": 187, "code": "Equal", "key": "+", "text": "+"},
+                    "{": {
+                        "keyCode": 219,
+                        "code": "BracketLeft",
+                        "key": "{",
+                        "text": "{",
+                    },
+                    "}": {
+                        "keyCode": 221,
+                        "code": "BracketRight",
+                        "key": "}",
+                        "text": "}",
+                    },
+                    "|": {"keyCode": 220, "code": "Backslash", "key": "|", "text": "|"},
+                    ":": {"keyCode": 186, "code": "Semicolon", "key": ":", "text": ":"},
+                    '"': {"keyCode": 222, "code": "Quote", "key": '"', "text": '"'},
+                    "<": {"keyCode": 188, "code": "Comma", "key": "<", "text": "<"},
+                    ">": {"keyCode": 190, "code": "Period", "key": ">", "text": ">"},
+                    "?": {"keyCode": 191, "code": "Slash", "key": "?", "text": "?"},
+                }
+                if char in symbol_map:
+                    return symbol_map[char]
+
+        return None
+
     @staticmethod
     def dispatch_key_event(
         chrome_interface: Any, key: str, modifiers: Optional[list] = None
     ) -> Dict[str, Any]:
         """
-        Dispatch key events using CDP.
+        Dispatch key events using CDP with full key definition support.
 
         Args:
             chrome_interface: Chrome DevTools Protocol interface
-            key: Key to dispatch (e.g., 'Enter', 'Up', 'Down')
-            modifiers: Optional list of modifiers ('ctrl', 'alt', 'shift')
+            key: Key to dispatch (e.g., 'a', 'Enter', 'Up', 'F1', any single character)
+            modifiers: Optional list of modifiers ('ctrl', 'alt', 'shift', 'meta')
 
         Returns:
             Result dictionary with success status
@@ -273,60 +370,94 @@ class JavaScriptExecutor:
             modifiers = []
 
         try:
-            key_name = key.lower().strip()
-            key_code = key_codes.get(key_name)
+            key_def = JavaScriptExecutor._get_key_definition(key)
 
-            if key_code is None:
+            if key_def is None:
                 return {
                     "success": False,
-                    "error": f"Unknown key '{key}'. Supported keys: {', '.join(sorted(key_codes.keys()))}",
+                    "error": f"Unknown key '{key}'. Supported: a-z, 0-9, symbols, and special keys (enter, escape, tab, f1-f12, up, down, left, right, etc.)",
                     "key": key,
                     "modifiers": modifiers,
                 }
 
+            key_code = key_def["keyCode"]
+            key_value = key_def["key"]
+            code_value = key_def["code"]
+            location = key_def.get("location", 0)
+            text_value = key_def.get("text", "")
+
             modifier_flags = 0
+            modifier_keys_to_press = []
             if modifiers:
                 modifier_names = [m.strip().lower() for m in modifiers]
                 for mod in modifier_names:
                     if mod in ["alt"]:
                         modifier_flags |= 1
+                        modifier_keys_to_press.append("alt")
                     elif mod in ["ctrl", "control"]:
                         modifier_flags |= 2
+                        modifier_keys_to_press.append("ctrl")
                     elif mod in ["meta", "cmd", "command"]:
                         modifier_flags |= 4
+                        modifier_keys_to_press.append("meta")
                     elif mod in ["shift"]:
                         modifier_flags |= 8
+                        modifier_keys_to_press.append("shift")
+
+            for mod_key in modifier_keys_to_press:
+                mod_def = key_definitions.get(mod_key)
+                if mod_def:
+                    chrome_interface.Input.dispatchKeyEvent(
+                        type="keyDown",
+                        key=mod_def["key"],
+                        code=mod_def["code"],
+                        windowsVirtualKeyCode=mod_def["keyCode"],
+                        location=mod_def.get("location", 0),
+                        modifiers=modifier_flags,
+                    )
 
             chrome_interface.Input.dispatchKeyEvent(
-                type="rawKeyDown",
+                type="keyDown",
+                key=key_value,
+                code=code_value,
                 windowsVirtualKeyCode=key_code,
+                location=location,
                 modifiers=modifier_flags,
             )
 
-            printable_keys = {"space", "spacebar", "enter", "return", "tab"}
-            if key_name in printable_keys:
-                if key_name in ["space", "spacebar"]:
-                    char_text = " "
-                elif key_name in ["enter", "return"]:
-                    char_text = "\r"
-                elif key_name == "tab":
-                    char_text = "\t"
-                else:
-                    char_text = ""
-
-                if char_text:
-                    chrome_interface.Input.dispatchKeyEvent(
-                        type="char",
-                        windowsVirtualKeyCode=key_code,
-                        text=char_text,
-                        unmodifiedText=char_text,
-                        modifiers=modifier_flags,
-                    )
+            if text_value:
+                chrome_interface.Input.dispatchKeyEvent(
+                    type="char",
+                    key=key_value,
+                    code=code_value,
+                    windowsVirtualKeyCode=key_code,
+                    text=text_value,
+                    unmodifiedText=text_value,
+                    location=location,
+                    modifiers=modifier_flags,
+                )
 
             chrome_interface.Input.dispatchKeyEvent(
-                type="keyUp", windowsVirtualKeyCode=key_code, modifiers=modifier_flags
+                type="keyUp",
+                key=key_value,
+                code=code_value,
+                windowsVirtualKeyCode=key_code,
+                location=location,
+                modifiers=modifier_flags,
             )
 
+            for mod_key in reversed(modifier_keys_to_press):
+                mod_def = key_definitions.get(mod_key)
+                if mod_def:
+                    chrome_interface.Input.dispatchKeyEvent(
+                        type="keyUp",
+                        key=mod_def["key"],
+                        code=mod_def["code"],
+                        windowsVirtualKeyCode=mod_def["keyCode"],
+                        location=mod_def.get("location", 0),
+                        modifiers=0,
+                    )
+
             time.sleep(0.1)
 
             return {
@@ -334,6 +465,8 @@ class JavaScriptExecutor:
                 "message": f"Successfully dispatched key '{key}' with modifiers '{modifiers}'",
                 "key": key,
                 "key_code": key_code,
+                "key_value": key_value,
+                "code_value": code_value,
                 "modifiers": modifiers,
                 "modifier_flags": modifier_flags,
             }
@@ -501,58 +634,69 @@ class JavaScriptLoader:
 
 js_loader = JavaScriptLoader()
 
-key_codes = {
-    "up": 38,
-    "down": 40,
-    "left": 37,
-    "right": 39,
-    "home": 36,
-    "end": 35,
-    "pageup": 33,
-    "pagedown": 34,
-    "enter": 13,
-    "escape": 27,
-    "tab": 9,
-    "backspace": 8,
-    "delete": 46,
-    "space": 32,
-    "f1": 112,
-    "f2": 113,
-    "f3": 114,
-    "f4": 115,
-    "f5": 116,
-    "f6": 117,
-    "f7": 118,
-    "f8": 119,
-    "f9": 120,
-    "f10": 121,
-    "f11": 122,
-    "f12": 123,
-    "numpad0": 96,
-    "numpad1": 97,
-    "numpad2": 98,
-    "numpad3": 99,
-    "numpad4": 100,
-    "numpad5": 101,
-    "numpad6": 102,
-    "numpad7": 103,
-    "numpad8": 104,
-    "numpad9": 105,
-    "volumeup": 175,
-    "volume_up": 175,
-    "volumedown": 174,
-    "volume_down": 174,
-    "volumemute": 173,
-    "volume_mute": 173,
-    "capslock": 20,
-    "numlock": 144,
-    "scrolllock": 145,
-    "shift": 16,
-    "ctrl": 17,
-    "control": 17,
-    "alt": 18,
-    "meta": 91,
-    "cmd": 91,
-    "command": 91,
-    "windows": 91,
+key_definitions = {
+    "up": {"keyCode": 38, "key": "ArrowUp", "code": "ArrowUp"},
+    "down": {"keyCode": 40, "key": "ArrowDown", "code": "ArrowDown"},
+    "left": {"keyCode": 37, "key": "ArrowLeft", "code": "ArrowLeft"},
+    "right": {"keyCode": 39, "key": "ArrowRight", "code": "ArrowRight"},
+    "home": {"keyCode": 36, "key": "Home", "code": "Home"},
+    "end": {"keyCode": 35, "key": "End", "code": "End"},
+    "pageup": {"keyCode": 33, "key": "PageUp", "code": "PageUp"},
+    "pagedown": {"keyCode": 34, "key": "PageDown", "code": "PageDown"},
+    "enter": {"keyCode": 13, "key": "Enter", "code": "Enter", "text": "\r"},
+    "escape": {"keyCode": 27, "key": "Escape", "code": "Escape"},
+    "tab": {"keyCode": 9, "key": "Tab", "code": "Tab", "text": "\t"},
+    "backspace": {"keyCode": 8, "key": "Backspace", "code": "Backspace"},
+    "delete": {"keyCode": 46, "key": "Delete", "code": "Delete"},
+    "space": {"keyCode": 32, "key": " ", "code": "Space", "text": " "},
+    "insert": {"keyCode": 45, "key": "Insert", "code": "Insert"},
+    "f1": {"keyCode": 112, "key": "F1", "code": "F1"},
+    "f2": {"keyCode": 113, "key": "F2", "code": "F2"},
+    "f3": {"keyCode": 114, "key": "F3", "code": "F3"},
+    "f4": {"keyCode": 115, "key": "F4", "code": "F4"},
+    "f5": {"keyCode": 116, "key": "F5", "code": "F5"},
+    "f6": {"keyCode": 117, "key": "F6", "code": "F6"},
+    "f7": {"keyCode": 118, "key": "F7", "code": "F7"},
+    "f8": {"keyCode": 119, "key": "F8", "code": "F8"},
+    "f9": {"keyCode": 120, "key": "F9", "code": "F9"},
+    "f10": {"keyCode": 121, "key": "F10", "code": "F10"},
+    "f11": {"keyCode": 122, "key": "F11", "code": "F11"},
+    "f12": {"keyCode": 123, "key": "F12", "code": "F12"},
+    "numpad0": {"keyCode": 96, "key": "0", "code": "Numpad0", "location": 3},
+    "numpad1": {"keyCode": 97, "key": "1", "code": "Numpad1", "location": 3},
+    "numpad2": {"keyCode": 98, "key": "2", "code": "Numpad2", "location": 3},
+    "numpad3": {"keyCode": 99, "key": "3", "code": "Numpad3", "location": 3},
+    "numpad4": {"keyCode": 100, "key": "4", "code": "Numpad4", "location": 3},
+    "numpad5": {"keyCode": 101, "key": "5", "code": "Numpad5", "location": 3},
+    "numpad6": {"keyCode": 102, "key": "6", "code": "Numpad6", "location": 3},
+    "numpad7": {"keyCode": 103, "key": "7", "code": "Numpad7", "location": 3},
+    "numpad8": {"keyCode": 104, "key": "8", "code": "Numpad8", "location": 3},
+    "numpad9": {"keyCode": 105, "key": "9", "code": "Numpad9", "location": 3},
+    "volumeup": {"keyCode": 175, "key": "AudioVolumeUp", "code": "AudioVolumeUp"},
+    "volume_up": {"keyCode": 175, "key": "AudioVolumeUp", "code": "AudioVolumeUp"},
+    "volumedown": {"keyCode": 174, "key": "AudioVolumeDown", "code": "AudioVolumeDown"},
+    "volume_down": {
+        "keyCode": 174,
+        "key": "AudioVolumeDown",
+        "code": "AudioVolumeDown",
+    },
+    "volumemute": {"keyCode": 173, "key": "AudioVolumeMute", "code": "AudioVolumeMute"},
+    "volume_mute": {
+        "keyCode": 173,
+        "key": "AudioVolumeMute",
+        "code": "AudioVolumeMute",
+    },
+    "capslock": {"keyCode": 20, "key": "CapsLock", "code": "CapsLock"},
+    "numlock": {"keyCode": 144, "key": "NumLock", "code": "NumLock"},
+    "scrolllock": {"keyCode": 145, "key": "ScrollLock", "code": "ScrollLock"},
+    "shift": {"keyCode": 16, "key": "Shift", "code": "ShiftLeft", "location": 1},
+    "ctrl": {"keyCode": 17, "key": "Control", "code": "ControlLeft", "location": 1},
+    "control": {"keyCode": 17, "key": "Control", "code": "ControlLeft", "location": 1},
+    "alt": {"keyCode": 18, "key": "Alt", "code": "AltLeft", "location": 1},
+    "meta": {"keyCode": 91, "key": "Meta", "code": "MetaLeft", "location": 1},
+    "cmd": {"keyCode": 91, "key": "Meta", "code": "MetaLeft", "location": 1},
+    "command": {"keyCode": 91, "key": "Meta", "code": "MetaLeft", "location": 1},
+    "windows": {"keyCode": 91, "key": "Meta", "code": "MetaLeft", "location": 1},
 }
+
+key_codes = {k: v["keyCode"] for k, v in key_definitions.items()}

{agentcrew_ai-0.8.10 → agentcrew_ai-0.8.12}/AgentCrew/modules/browser_automation/service.py

@@ -137,6 +137,39 @@ class BrowserAutomationService:
                 "profile": profile,
             }
 
+    def refresh(self) -> Dict[str, Any]:
+        """
+        Refresh the current page.
+
+        Returns:
+            Dict containing refresh result
+        """
+        try:
+            self._ensure_chrome_running()
+            if self.chrome_interface is None:
+                raise RuntimeError("Chrome interface is not initialized")
+
+            self.chrome_interface.Page.reload()
+
+            import time
+
+            time.sleep(0.5)
+
+            current_url = JavaScriptExecutor.get_current_url(self.chrome_interface)
+
+            return {
+                "success": True,
+                "message": "Successfully refreshed the page",
+                "current_url": current_url,
+            }
+
+        except Exception as e:
+            logger.error(f"Refresh error: {e}")
+            return {
+                "success": False,
+                "error": f"Refresh error: {str(e)}",
+            }
+
     def click_element(self, element_uuid: str) -> Dict[str, Any]:
         """
         Click an element using UUID via Chrome DevTools Protocol.