vibesurf 0.1.36__py3-none-any.whl → 0.1.37__py3-none-any.whl

vibe_surf/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.36'
-__version_tuple__ = version_tuple = (0, 1, 36)
+__version__ = version = '0.1.37'
+__version_tuple__ = version_tuple = (0, 1, 37)
 
 __commit_id__ = commit_id = None

vibe_surf/agents/browser_use_agent.py

@@ -72,7 +72,7 @@ from browser_use.utils import (
     time_execution_async,
     time_execution_sync,
 )
-
+from browser_use.llm.messages import BaseMessage, ContentPartImageParam, ContentPartTextParam, UserMessage
 from browser_use.agent.service import Agent, AgentHookFunc
 from vibe_surf.tools.file_system import CustomFileSystem
 from vibe_surf.telemetry.service import ProductTelemetry
@@ -107,6 +107,7 @@ class BrowserUseAgent(Agent):
                     | None
             ) = None,
             register_external_agent_status_raise_error_callback: Callable[[], Awaitable[bool]] | None = None,
+            register_should_stop_callback: Callable[[], Awaitable[bool]] | None = None,
             # Agent settings
             output_model_schema: type[AgentStructuredOutput] | None = None,
             use_vision: bool = True,
@@ -127,7 +128,6 @@ class BrowserUseAgent(Agent):
             source: str | None = None,
             file_system_path: str | None = None,
             task_id: str | None = None,
-            cloud_sync: CloudSync | None = None,
             calculate_cost: bool = False,
             display_files_in_done_text: bool = True,
             include_tool_call_examples: bool = False,
@@ -136,7 +136,9 @@ class BrowserUseAgent(Agent):
             step_timeout: int = 120,
             directly_open_url: bool = False,
             include_recent_events: bool = False,
-            allow_parallel_action_types: list[str] = ["extract_structured_data", "extract_content_from_file"],
+            sample_images: list[ContentPartTextParam | ContentPartImageParam] | None = None,
+            final_response_after_failure: bool = True,
+            allow_parallel_action_types: list[str] = ["extract", "extract_content_from_file"],
             _url_shortening_limit: int = 25,
             token_cost_service: Optional[TokenCost] = None,
             **kwargs,
@@ -151,7 +153,7 @@ class BrowserUseAgent(Agent):
         self.session_id: str = uuid7str()
         self.allow_parallel_action_types = allow_parallel_action_types
         self._url_shortening_limit = _url_shortening_limit
-
+        self.sample_images = sample_images
         browser_profile = browser_profile or DEFAULT_BROWSER_PROFILE
 
         # Handle browser vs browser_session parameter (browser takes precedence)
@@ -206,6 +208,7 @@ class BrowserUseAgent(Agent):
             include_tool_call_examples=include_tool_call_examples,
             llm_timeout=llm_timeout,
             step_timeout=step_timeout,
+            final_response_after_failure=final_response_after_failure,
         )
 
         # Token cost service
@@ -289,7 +292,6 @@ class BrowserUseAgent(Agent):
         self._message_manager = MessageManager(
             task=task,
             system_message=SystemPrompt(
-                action_description=self.unfiltered_actions,
                 max_actions_per_step=self.settings.max_actions_per_step,
                 override_system_message=override_system_message,
                 extend_system_message=extend_system_message,
@@ -306,6 +308,7 @@ class BrowserUseAgent(Agent):
             vision_detail_level=self.settings.vision_detail_level,
             include_tool_call_examples=self.settings.include_tool_call_examples,
             include_recent_events=self.include_recent_events,
+            sample_images=self.sample_images,
         )
 
         if self.sensitive_data:
@@ -375,6 +378,7 @@ class BrowserUseAgent(Agent):
         # Callbacks
         self.register_new_step_callback = register_new_step_callback
         self.register_done_callback = register_done_callback
+        self.register_should_stop_callback = register_should_stop_callback
         self.register_external_agent_status_raise_error_callback = register_external_agent_status_raise_error_callback
 
         # Telemetry
@@ -463,7 +467,7 @@ class BrowserUseAgent(Agent):
 
             # Use _make_history_item like main branch
             await self._make_history_item(self.state.last_model_output, browser_state_summary, self.state.last_result,
-                                          metadata)
+                                          metadata, state_message=self._message_manager.last_state_message_text,)
 
         # Log step completion summary
         self._log_step_completion_summary(self.step_start_time, self.state.last_result)
@@ -490,6 +494,9 @@ class BrowserUseAgent(Agent):
         self.task = new_task
         self._message_manager.add_new_task(new_task)
 
+        # Mark as follow-up task and recreate eventbus (gets shut down after each run)
+        self.state.follow_up_task = True
+
     @observe(name='agent.run', metadata={'task': '{{task}}', 'debug': '{{debug}}'})
     @time_execution_async('--run')
     async def run(
@@ -749,273 +756,4 @@ class BrowserUseAgent(Agent):
         # Add the last group
         groups.append(current_group)
 
-        return groups
-
-    @observe_debug(ignore_input=True, ignore_output=True)
-    @time_execution_async('--multi_act')
-    async def multi_act(
-            self,
-            actions: list[ActionModel],
-            check_for_new_elements: bool = True,
-    ) -> list[ActionResult]:
-        """Execute multiple actions, with parallel execution for allowed action types"""
-        results: list[ActionResult] = []
-        time_elapsed = 0
-        total_actions = len(actions)
-
-        assert self.browser_session is not None, 'BrowserSession is not set up'
-        try:
-            if (
-                    self.browser_session._cached_browser_state_summary is not None
-                    and self.browser_session._cached_browser_state_summary.dom_state is not None
-            ):
-                cached_selector_map = dict(self.browser_session._cached_browser_state_summary.dom_state.selector_map)
-                cached_element_hashes = {e.parent_branch_hash() for e in cached_selector_map.values()}
-            else:
-                cached_selector_map = {}
-                cached_element_hashes = set()
-        except Exception as e:
-            self.logger.error(f'Error getting cached selector map: {e}')
-            cached_selector_map = {}
-            cached_element_hashes = set()
-
-        # Group actions for potential parallel execution
-        action_groups = self._group_actions_for_parallel_execution(actions)
-
-        # Track global action index for logging and DOM checks
-        global_action_index = 0
-
-        for group_index, action_group in enumerate(action_groups):
-            group_size = len(action_group)
-
-            # Check if this group can be executed in parallel
-            can_execute_in_parallel = (
-                    group_size > 1 and
-                    all(self._is_action_parallel_allowed(action) for action in action_group)
-            )
-
-            if can_execute_in_parallel:
-                self.logger.info(
-                    f'🚀 Executing {group_size} actions in parallel: group {group_index + 1}/{len(action_groups)}')
-                # Execute actions in parallel using asyncio.gather
-                parallel_results = await self._execute_actions_in_parallel(
-                    action_group, global_action_index, total_actions,
-                    cached_selector_map, cached_element_hashes, check_for_new_elements
-                )
-                results.extend(parallel_results)
-                global_action_index += group_size
-
-                # Check if any result indicates completion or error
-                if any(result.is_done or result.error for result in parallel_results):
-                    break
-            else:
-                # Execute actions sequentially
-                for local_index, action in enumerate(action_group):
-                    i = global_action_index + local_index
-
-                    # Original sequential execution logic continues here...
-                    # if i > 0:
-                    #     # ONLY ALLOW TO CALL `done` IF IT IS A SINGLE ACTION
-                    #     if action.model_dump(exclude_unset=True).get('done') is not None:
-                    #         msg = f'Done action is allowed only as a single action - stopped after action {i} / {total_actions}.'
-                    #         self.logger.debug(msg)
-                    #         break
-
-                    # DOM synchronization check - verify element indexes are still valid AFTER first action
-                    if action.get_index() is not None and i != 0:
-                        result = await self._check_dom_synchronization(
-                            action, i, total_actions, cached_selector_map, cached_element_hashes,
-                            check_for_new_elements, actions
-                        )
-                        if result:
-                            results.append(result)
-                            break
-
-                    # wait between actions (only after first action)
-                    if i > 0:
-                        await asyncio.sleep(self.browser_profile.wait_between_actions)
-
-                    # Execute single action
-                    try:
-                        action_result = await self._execute_single_action(action, i, total_actions)
-                        results.append(action_result)
-
-                        if action_result.is_done or action_result.error or i == total_actions - 1:
-                            break
-
-                    except Exception as e:
-                        self.logger.error(f'❌ Executing action {i + 1} failed: {type(e).__name__}: {e}')
-                        raise e
-
-                global_action_index += len(action_group)
-
-        return results
-
-    async def _execute_actions_in_parallel(
-            self,
-            actions: list[ActionModel],
-            start_index: int,
-            total_actions: int,
-            cached_selector_map: dict,
-            cached_element_hashes: set,
-            check_for_new_elements: bool
-    ) -> list[ActionResult]:
-        """Execute a group of actions in parallel using asyncio.gather"""
-
-        async def execute_single_parallel_action(action: ActionModel, action_index: int) -> ActionResult:
-            """Execute a single action for parallel execution"""
-            await self._raise_if_stopped_or_paused()
-
-            # Get action info for logging
-            action_data = action.model_dump(exclude_unset=True)
-            action_name = next(iter(action_data.keys())) if action_data else 'unknown'
-            action_params = getattr(action, action_name, '') or str(action.model_dump(mode='json'))[:140].replace(
-                '"', ''
-            ).replace('{', '').replace('}', '').replace("'", '').strip().strip(',')
-            action_params = str(action_params)
-            action_params = f'{action_params[:122]}...' if len(action_params) > 128 else action_params
-
-            time_start = time.time()
-            blue = '\033[34m'
-            reset = '\033[0m'
-            self.logger.info(f'  🦾 {blue}[PARALLEL ACTION {action_index + 1}/{total_actions}]{reset} {action_params}')
-
-            # Execute the action
-            result = await self.tools.act(
-                action=action,
-                browser_session=self.browser_session,
-                file_system=self.file_system,
-                page_extraction_llm=self.settings.page_extraction_llm,
-                sensitive_data=self.sensitive_data,
-                available_file_paths=self.available_file_paths,
-            )
-
-            time_end = time.time()
-            time_elapsed = time_end - time_start
-
-            green = '\033[92m'
-            self.logger.debug(
-                f'☑️ Parallel action {action_index + 1}/{total_actions}: {green}{action_params}{reset} in {time_elapsed:.2f}s'
-            )
-
-            return result
-
-        # Create tasks for parallel execution
-        tasks = [
-            execute_single_parallel_action(action, start_index + i)
-            for i, action in enumerate(actions)
-        ]
-
-        # Execute all tasks in parallel
-        parallel_results = await asyncio.gather(*tasks, return_exceptions=True)
-
-        # Process results and handle any exceptions
-        processed_results = []
-        for i, result in enumerate(parallel_results):
-            if isinstance(result, Exception):
-                action_index = start_index + i
-                self.logger.error(f'❌ Parallel action {action_index + 1} failed: {type(result).__name__}: {result}')
-                raise result
-            else:
-                processed_results.append(result)
-
-        return processed_results
-
-    async def _check_dom_synchronization(
-            self,
-            action: ActionModel,
-            action_index: int,
-            total_actions: int,
-            cached_selector_map: dict,
-            cached_element_hashes: set,
-            check_for_new_elements: bool,
-            all_actions: list[ActionModel]
-    ) -> ActionResult | None:
-        """Check DOM synchronization and return result if page changed"""
-        new_browser_state_summary = await self.browser_session.get_browser_state_summary(
-            cache_clickable_elements_hashes=False,
-            include_screenshot=False,
-        )
-        new_selector_map = new_browser_state_summary.dom_state.selector_map
-
-        # Detect index change after previous action
-        orig_target = cached_selector_map.get(action.get_index())
-        orig_target_hash = orig_target.parent_branch_hash() if orig_target else None
-
-        new_target = new_selector_map.get(action.get_index())  # type: ignore
-        new_target_hash = new_target.parent_branch_hash() if new_target else None
-
-        def get_remaining_actions_str(actions: list[ActionModel], index: int) -> str:
-            remaining_actions = []
-            for remaining_action in actions[index:]:
-                action_data = remaining_action.model_dump(exclude_unset=True)
-                action_name = next(iter(action_data.keys())) if action_data else 'unknown'
-                remaining_actions.append(action_name)
-            return ', '.join(remaining_actions)
-
-        if orig_target_hash != new_target_hash:
-            # Get names of remaining actions that won't be executed
-            remaining_actions_str = get_remaining_actions_str(all_actions, action_index)
-            msg = f'Page changed after action {action_index} / {total_actions}: actions {remaining_actions_str} were not executed'
-            self.logger.info(msg)
-            return ActionResult(
-                extracted_content=msg,
-                include_in_memory=True,
-                long_term_memory=msg,
-            )
-
-        # Check for new elements that appeared
-        new_element_hashes = {e.parent_branch_hash() for e in new_selector_map.values()}
-        if check_for_new_elements and not new_element_hashes.issubset(cached_element_hashes):
-            # next action requires index but there are new elements on the page
-            remaining_actions_str = get_remaining_actions_str(all_actions, action_index)
-            msg = f'Something new appeared after action {action_index} / {total_actions}: actions {remaining_actions_str} were not executed'
-            self.logger.info(msg)
-            return ActionResult(
-                extracted_content=msg,
-                include_in_memory=True,
-                long_term_memory=msg,
-            )
-
-        return None
-
-    async def _execute_single_action(self, action: ActionModel, action_index: int, total_actions: int) -> ActionResult:
-        """Execute a single action in sequential mode"""
-        await self._raise_if_stopped_or_paused()
-
-        # Get action name from the action model
-        action_data = action.model_dump(exclude_unset=True)
-        action_name = next(iter(action_data.keys())) if action_data else 'unknown'
-        action_params = getattr(action, action_name, '') or str(action.model_dump(mode='json'))[:140].replace(
-            '"', ''
-        ).replace('{', '').replace('}', '').replace("'", '').strip().strip(',')
-        # Ensure action_params is always a string before checking length
-        action_params = str(action_params)
-        action_params = f'{action_params[:122]}...' if len(action_params) > 128 else action_params
-
-        time_start = time.time()
-
-        red = '\033[91m'
-        green = '\033[92m'
-        blue = '\033[34m'
-        reset = '\033[0m'
-
-        self.logger.info(f'  🦾 {blue}[ACTION {action_index + 1}/{total_actions}]{reset} {action_params}')
-
-        result = await self.tools.act(
-            action=action,
-            browser_session=self.browser_session,
-            file_system=self.file_system,
-            page_extraction_llm=self.settings.page_extraction_llm,
-            sensitive_data=self.sensitive_data,
-            available_file_paths=self.available_file_paths,
-        )
-
-        time_end = time.time()
-        time_elapsed = time_end - time_start
-
-        self.logger.debug(
-            f'☑️ Executed action {action_index + 1}/{total_actions}: {green}{action_params}{reset} in {time_elapsed:.2f}s'
-        )
-
-        return result
+        return groups

vibe_surf/agents/report_writer_agent.py

@@ -157,7 +157,27 @@ class ReportWriterAgent:
 
             # Add system message with unified prompt only if message history is empty
             if not self.message_history:
-                self.message_history.append(SystemMessage(content=REPORT_WRITER_PROMPT))
+                report_system_prompt = REPORT_WRITER_PROMPT
+                if self.use_thinking:
+                    report_system_prompt += """
+                    You must ALWAYS respond with a valid JSON in this exact format:
+                    {{
+                      "thinking": "A structured <think>-style reasoning.",
+                      "action":[{{"task_done": {{ }}, // ... more actions in sequence]
+                    }}
+        
+                    Action list should NEVER be empty.
+                    """
+                else:
+                    report_system_prompt += """
+                    You must ALWAYS respond with a valid JSON in this exact format:
+                    {{
+                      "action":[{{"task_done": {{ }}, // ... more actions in sequence]
+                    }}
+    
+                    Action list should NEVER be empty.
+                    """
+                self.message_history.append(SystemMessage(content=report_system_prompt))
 
             # Add initial user message with task details
             user_message = f"""Please generate a report within MAX {max_iterations} steps based on the following:

vibe_surf/agents/vibe_surf_agent.py

@@ -41,7 +41,11 @@ from vibe_surf.tools.file_system import CustomFileSystem
 from vibe_surf.agents.views import VibeSurfAgentSettings
 
 from vibe_surf.telemetry.service import ProductTelemetry
-from vibe_surf.telemetry.views import VibeSurfAgentTelemetryEvent
+from vibe_surf.telemetry.views import (
+    VibeSurfAgentTelemetryEvent,
+    VibeSurfAgentParsedOutputEvent,
+    VibeSurfAgentExceptionEvent
+)
 
 from vibe_surf.logger import get_logger
 
@@ -400,6 +404,25 @@ async def _vibesurf_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
             AssistantMessage(content=json.dumps(response.completion.model_dump(exclude_none=True, exclude_unset=True),
                                                 ensure_ascii=False)))
 
+        # Capture telemetry for parsed output
+        import vibe_surf
+        action_types = []
+        for action in actions:
+            action_data = action.model_dump(exclude_unset=True)
+            action_name = next(iter(action_data.keys())) if action_data else 'unknown'
+            action_types.append(action_name)
+        
+        parsed_output_event = VibeSurfAgentParsedOutputEvent(
+            version=vibe_surf.__version__,
+            parsed_output=json.dumps(parsed.model_dump(exclude_none=True, exclude_unset=True), ensure_ascii=False),  # Limit size
+            action_count=len(actions),
+            action_types=action_types,
+            model=getattr(vibesurf_agent.llm, 'model_name', None),
+            session_id=state.session_id,
+        )
+        vibesurf_agent.telemetry.capture(parsed_output_event)
+        vibesurf_agent.telemetry.flush()
+
         # Log thinking if present
         if hasattr(parsed, 'thinking') and parsed.thinking:
             await log_agent_activity(state, agent_name, "thinking", parsed.thinking)
@@ -505,8 +528,24 @@ async def _vibesurf_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
 
     except Exception as e:
         import traceback
+        traceback_str = traceback.format_exc()
         traceback.print_exc()
         logger.error(f"❌ VibeSurf agent failed: {e}")
+        
+        # Capture telemetry for exception
+        import vibe_surf
+        exception_event = VibeSurfAgentExceptionEvent(
+            version=vibe_surf.__version__,
+            error_message=str(e)[:500],  # Limit error message length
+            error_type=type(e).__name__,
+            traceback=traceback_str[:1000],  # Limit traceback length
+            model=getattr(vibesurf_agent.llm, 'model_name', None),
+            session_id=state.session_id,
+            function_name='_vibesurf_agent_node_impl'
+        )
+        vibesurf_agent.telemetry.capture(exception_event)
+        vibesurf_agent.telemetry.flush()
+
         state.final_response = f"Task execution failed: {str(e)}"
         state.is_complete = True
         await log_agent_activity(state, agent_name, "error", f"Agent failed: {str(e)}")
@@ -1606,7 +1645,27 @@ Please continue with your assigned work, incorporating this guidance only if it'
             upload_files = await self.process_upload_files(upload_files)
 
             if not self.message_history:
-                self.message_history.append(SystemMessage(content=VIBESURF_SYSTEM_PROMPT))
+                vibesurf_system_prompt = VIBESURF_SYSTEM_PROMPT
+                if self.settings.agent_mode == "thinking":
+                    vibesurf_system_prompt += """
+You must ALWAYS respond with a valid JSON in this exact format:
+{{
+  "thinking": "A structured <think>-style reasoning.",
+  "action":[{{"task_done": {{ }}, // ... more actions in sequence]
+}}
+
+Action list should NEVER be empty.
+                    """
+                else:
+                    vibesurf_system_prompt += """
+You must ALWAYS respond with a valid JSON in this exact format:
+{{
+  "action":[{{"task_done": {{ }}, // ... more actions in sequence]
+}}
+
+Action list should NEVER be empty.
+                    """
+                self.message_history.append(SystemMessage(content=vibesurf_system_prompt))
 
             # Format processed upload files for prompt
             user_request = f"* User's New Request:\n{task}\n"

vibe_surf/backend/llm_config.py

@@ -24,6 +24,17 @@ LLM_PROVIDERS = {
         "gemini-2.5-pro",
         "gemini-2.5-flash",
     ],
+    "kimi": [
+        "kimi-k2-0905-preview",
+        "kimi-k2-0711-preview",
+        "kimi-k2-turbo-preview"
+    ],
+    "qwen": [
+        "qwen-flash",
+        "qwen-plus",
+        "qwen3-vl-plus",
+        "qwen3-vl-flash"
+    ],
     "azure_openai": [
         "gpt-4o",
         "gpt-4o-mini",
@@ -152,6 +163,22 @@ PROVIDER_METADATA = {
         "supports_tools": True,
         "supports_vision": True,
         "default_model": ""
+    },
+    "qwen": {
+        "display_name": "Qwen",
+        "requires_api_key": True,
+        "requires_base_url": True,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": ""
+    },
+    "kimi": {
+        "display_name": "Kimi",
+        "requires_api_key": True,
+        "requires_base_url": True,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": ""
     }
 }
 

vibe_surf/backend/shared_state.py

@@ -505,32 +505,6 @@ async def initialize_vibesurf_components():
         # Initialize LLM from default profile (if available) or fallback to environment variables
         llm = await _initialize_default_llm()
 
-        # Initialize browser manager
-        if browser_manager:
-            main_browser_session = browser_manager.main_browser_session
-        else:
-            from screeninfo import get_monitors
-            primary_monitor = get_monitors()[0]
-            _update_extension_backend_url(envs["VIBESURF_EXTENSION"], backend_url)
-            
-            browser_profile = AgentBrowserProfile(
-                executable_path=browser_execution_path,
-                user_data_dir=browser_user_data,
-                headless=False,
-                keep_alive=True,
-                auto_download_pdfs=False,
-                highlight_elements=True,
-                custom_extensions=[envs["VIBESURF_EXTENSION"]],
-                window_size={"width": primary_monitor.width, "height": primary_monitor.height}
-            )
-
-            # Initialize components
-            main_browser_session = AgentBrowserSession(browser_profile=browser_profile)
-            await main_browser_session.start()
-        browser_manager = BrowserManager(
-            main_browser_session=main_browser_session
-        )
-
         # Load active MCP servers from database
         mcp_server_config = await _load_active_mcp_servers()
 
@@ -564,6 +538,32 @@ async def initialize_vibesurf_components():
             )
             logger.info(f"✅ Registered Composio tools from {len(toolkit_tools_dict)} enabled toolkits")
 
+        # Initialize browser manager
+        if browser_manager:
+            main_browser_session = browser_manager.main_browser_session
+        else:
+            from screeninfo import get_monitors
+            primary_monitor = get_monitors()[0]
+            _update_extension_backend_url(envs["VIBESURF_EXTENSION"], backend_url)
+
+            browser_profile = AgentBrowserProfile(
+                executable_path=browser_execution_path,
+                user_data_dir=browser_user_data,
+                headless=False,
+                keep_alive=True,
+                auto_download_pdfs=False,
+                highlight_elements=True,
+                custom_extensions=[envs["VIBESURF_EXTENSION"]],
+                window_size={"width": primary_monitor.width, "height": primary_monitor.height}
+            )
+
+            # Initialize components
+            main_browser_session = AgentBrowserSession(browser_profile=browser_profile)
+            await main_browser_session.start()
+        browser_manager = BrowserManager(
+            main_browser_session=main_browser_session
+        )
+
         # Initialize VibeSurfAgent
         vibesurf_agent = VibeSurfAgent(
             llm=llm,

vibe_surf/backend/utils/encryption.py

@@ -39,9 +39,38 @@ def derive_key(machine_id: str, salt: bytes = None) -> bytes:
     key = base64.urlsafe_b64encode(kdf.derive(password))
     return key
 
-def get_encryption_key() -> bytes:
+def get_local_user_id():
+    _curr_user_id = "vibesurf_userid"
+    try:
+        from uuid_extensions import uuid7str
+        import os
+        WORKSPACE_DIR = os.getenv('VIBESURF_WORKSPACE', './vibesurf_workspace')
+        USER_ID_PATH = os.path.join(WORKSPACE_DIR, 'telemetry', 'userid')
+
+        if not os.path.exists(USER_ID_PATH):
+            os.makedirs(os.path.dirname(USER_ID_PATH), exist_ok=True)
+            with open(USER_ID_PATH, 'w') as f:
+                new_user_id = uuid7str()
+                f.write(new_user_id)
+            _curr_user_id = new_user_id
+        else:
+            with open(USER_ID_PATH) as f:
+                _curr_user_id = f.read()
+        return _curr_user_id
+    except Exception as e:
+        logger.error(e)
+        return _curr_user_id
+
+
+def get_encryption_key(use_local_userid=False) -> bytes:
     """Get the encryption key for this machine."""
-    machine_id1 = get_mac_address()
+    machine_id1 = ''
+    if not use_local_userid:
+        machine_id1 = get_mac_address()
+    if not machine_id1:
+        logger.info("Use local user id as encryption key.")
+        # fallback to get user id
+        machine_id1 = get_local_user_id()
     return derive_key(machine_id1)
 
 def encrypt_api_key(api_key: str) -> str:
@@ -86,8 +115,15 @@ def decrypt_api_key(encrypted_api_key: str) -> str:
         decrypted_data = fernet.decrypt(encrypted_data)
         return decrypted_data.decode('utf-8')
     except Exception as e:
-        logger.error(f"Failed to decrypt API key: {e}")
-        raise ValueError("Decryption failed")
+        try:
+            key = get_encryption_key(use_local_userid=True)
+            fernet = Fernet(key)
+            encrypted_data = base64.urlsafe_b64decode(encrypted_api_key.encode('utf-8'))
+            decrypted_data = fernet.decrypt(encrypted_data)
+            return decrypted_data.decode('utf-8')
+        except Exception as e:
+            logger.error(f"Failed to decrypt API key: {e}")
+            raise ValueError("Decryption failed")
 
 def is_encrypted(value: str) -> bool:
     """