Merge pull request #190 from scszcoder/dev

Dev

Author: liulongqiang1984

agent/cloud_api/appsync_schema.graphql

@@ -600,6 +600,9 @@ type WanChatMessage @aws_api_key @aws_cognito_user_pools {
 	chatID: String
 	sender: String
 	receiver: String
+	type: String
+	contents: String
+	parameters: String
 	msg: String
 	options: AWSJSON
 	background: String

agent/cloud_api/cloud_api.py

@@ -2230,8 +2230,15 @@ def safe_parse_response(jresp, operation_name, data_key):
                 return response_data
         else:
             # No data and errors - this is a failure
-            logger.error(f"❌ GraphQL Error: {error_message}")
-            logger.error(f"📋 Full error response: {json.dumps(jresp, ensure_ascii=False)}")
+            # Detect "Cannot return null for non-nullable type" as a known backend schema issue
+            is_schema_null_error = "Cannot return null for non-nullable type" in error_message
+            if is_schema_null_error:
+                logger.error(f"❌ GraphQL Schema Error: {error_message}")
+                logger.error(f"📋 This is a known backend issue: AppSync resolver returned null for a non-nullable field.")
+                logger.error(f"📋 Action required: Check AppSync Lambda resolver for '{operation_name}' - ensure it returns all required fields.")
+            else:
+                logger.error(f"❌ GraphQL Error: {error_message}")
+                logger.error(f"📋 Full error response: {json.dumps(jresp, ensure_ascii=False)}")
             raise Exception(f"{operation_name} failed: {error_message}")
     else:
         if response_data is not None:
@@ -2252,6 +2259,7 @@ def safe_parse_response(jresp, operation_name, data_key):
             logger.debug(f"   3. Data validation failed on server")
             logger.debug(f"   4. Permission denied (check IAM/Cognito)")
             logger.debug(f"   5. Backend timeout or internal error")
+            return None
 
 # =================================================================================================
 # interface appsync, directly use HTTP request.

agent/ec_skills/browser_use_extension/deepseek_adapter.py

@@ -16,8 +16,6 @@
 """
 
 import json
-import logging
-import re
 from typing import Any, Dict, List, Optional
 
 from utils.logger_helper import logger_helper as logger
@@ -31,11 +29,14 @@ class DeepSeekOutputAdapter:
         adapter = DeepSeekOutputAdapter()
     """
 
-    # Valid browser-use action types
+    # Valid browser-use action types (current version)
     VALID_ACTIONS = {
-        'go_to_url', 'click', 'input_text', 'scroll', 'extract',
-        'done', 'search_google', 'open_tab', 'go_back', 'switch_tab',
-        'close_tab', 'save_file', 'get_dropdown_options', 'select_dropdown_option'
+        'navigate', 'click', 'input', 'scroll', 'extract',
+        'done', 'search', 'go_back', 'wait', 'switch', 'close',
+        'send_keys', 'find_text', 'upload_file', 'dropdown_options', 'select_dropdown',
+        # Legacy names (still accepted for filtering, will be remapped elsewhere)
+        'go_to_url', 'input_text', 'search_google', 'open_tab', 'switch_tab',
+        'close_tab', 'click_element', 'extract_content', 'scroll_down', 'scroll_up',
     }
 
     # Invalid actions that DeepSeek sometimes generates

agent/ec_skills/browser_use_extension/qwen_adapter.py

@@ -0,0 +1,59 @@
+"""
+Monkey-patch browser_use BrowserSession to increase navigation timeout.
+
+browser_use hardcodes page readiness timeout at 4s (cross-domain) / 2s (same-domain)
+in BrowserSession._navigate_and_wait. This is too short for many real-world sites
+(e.g. baidu.com, amazon.com) that have heavy async loading.
+
+This patch increases the defaults to reduce "Page readiness timeout" warnings.
+The patch is idempotent — calling it multiple times is safe.
+"""
+
+
+from utils.logger_helper import logger_helper as logger
+
+_patched = False
+
+
+def patch_navigation_timeout(cross_domain_timeout: float = 10.0, same_domain_timeout: float = 5.0):
+    """
+    Patch BrowserSession._navigate_and_wait to use larger default timeouts.
+    
+    Args:
+        cross_domain_timeout: Timeout for cross-domain navigation (default: 10s, was 4s)
+        same_domain_timeout: Timeout for same-domain navigation (default: 5s, was 2s)
+    """
+    global _patched
+    if _patched:
+        return
+    
+    try:
+        from browser_use.browser.session import BrowserSession
+        import asyncio
+        
+        original_navigate_and_wait = BrowserSession._navigate_and_wait
+        
+        async def _patched_navigate_and_wait(self, url: str, target_id: str, timeout: float | None = None):
+            """Patched version with increased default timeouts."""
+            if timeout is None:
+                # Use our increased timeouts instead of the hardcoded 4s/2s
+                try:
+                    target = self.session_manager.get_target(target_id)
+                    current_url = target.url
+                    same_domain = (
+                        url.split('/')[2] == current_url.split('/')[2]
+                        if url.startswith('http') and current_url.startswith('http')
+                        else False
+                    )
+                    timeout = same_domain_timeout if same_domain else cross_domain_timeout
+                except Exception:
+                    timeout = cross_domain_timeout
+            
+            return await original_navigate_and_wait(self, url, target_id, timeout=timeout)
+        
+        BrowserSession._navigate_and_wait = _patched_navigate_and_wait
+        _patched = True
+        logger.info(f"[SessionPatch] ✅ Patched navigation timeout: cross-domain={cross_domain_timeout}s, same-domain={same_domain_timeout}s")
+        
+    except Exception as e:
+        logger.warning(f"[SessionPatch] ⚠️ Failed to patch navigation timeout: {e}")

agent/ec_skills/browser_use_extension/session_patch.py

@@ -644,7 +644,7 @@ def build_llm_node(config_metadata: dict, node_name, skill_name, owner, bp_manag
         hard_timeout_config = str(hard_timeout_val).lower() in ('true', '1', 'yes', 'on') if hard_timeout_val else False
     except Exception:
         pass
-    # Prefer explicit provider; infer from apiHost if absent
+    # Get explicit provider from frontend (guaranteed by form-meta.tsx)
     raw_provider = None
     try:
         raw_provider = ((inputs.get("modelProvider") or {}).get("content")
@@ -705,28 +705,13 @@ def build_llm_node(config_metadata: dict, node_name, skill_name, owner, bp_manag
         user_prompt_template = get_prompt_content(user_prompt_id, resolved_user_prompt)
     else:
         user_prompt_template = resolved_user_prompt
-    # Infer provider when not explicitly set
-    def _infer_provider(host: str, model: str) -> str:
-        try:
-            h = (host or "").lower()
-            m = (model or "").lower()
-            if "anthropic" in h or m.startswith("claude"):
-                return "anthropic"
-            if "google" in h or "generativeai" in h or m.startswith("gemini"):
-                return "google"
-            return "openai"
-        except Exception:
-            return "openai"
-
-    model_provider = raw_provider or _infer_provider(api_host, model_name)
-    llm_provider = (model_provider or "openai").lower()
-
     # Normalize provider names dynamically from llm_manager
     # This automatically syncs with gui/config/llm_providers.json
     def _get_provider_mapping() -> dict:
         """
         Dynamically build provider mapping from llm_manager.
-        This ensures consistency with llm_providers.json and reduces maintenance.
+        Maps all known name variants (name, display_name, class_name, provider_id)
+        to the canonical provider_id. No hardcoded provider list needed.
         
         Returns:
             Dictionary mapping various provider name formats to canonical provider identifiers
@@ -774,18 +759,17 @@ def _get_provider_mapping() -> dict:
             return {}
 
     # Get dynamic provider mapping from llm_manager
-    # This automatically includes all providers defined in llm_providers.json:
-    # - provider_id (e.g., "deepseek")
-    # - name (e.g., "DeepSeek")
-    # - display_name
-    # - class_name (e.g., "ChatDeepSeek")
+    # Resolves any name variant (name/display_name/class_name/provider_id) → canonical provider_id
     provider_mapping = _get_provider_mapping()
+
+    # Resolve raw_provider (e.g. "DeepSeek", "Qwen (DashScope)") to canonical provider_id (e.g. "deepseek", "dashscope")
+    # Frontend is responsible for always passing correct modelProvider via form-meta.tsx
+    model_provider = provider_mapping.get((raw_provider or "").lower(), raw_provider or "openai")
+    llm_provider = (model_provider or "openai").lower()
 
     logger.info(f"llm config: system_prompt_template='{system_prompt_template}' user_prompt_template='{user_prompt_template}' ")
     logger.info(f"llm config: model_name={model_name} api_host={api_host} api_key={api_key} model_provider={model_provider} llm_provider={llm_provider}")
 
-    llm_provider = provider_mapping.get(llm_provider, llm_provider)
-
     # This is the actual function that will be executed as the node in the graph
     def llm_node_callable(state: dict, runtime=None, store=None, **kwargs) -> dict:
         """
@@ -3262,6 +3246,11 @@ async def _run_browser_use(task: str, mainwin, state: dict | None = None, callin
             from browser_use.browser.profile import BrowserProfile
             from agent.ec_skills.browser_use_extension.extension_tools_service import custom_controller
             # from browser_use.browser.context import BUBrowserContext as BUBrowserContext
+            
+            # Patch navigation timeout to reduce "Page readiness timeout" warnings
+            # browser_use hardcodes 4s cross-domain / 2s same-domain, which is too short for many sites
+            from agent.ec_skills.browser_use_extension.session_patch import patch_navigation_timeout
+            patch_navigation_timeout(cross_domain_timeout=10.0, same_domain_timeout=5.0)
             log_msg = f"🤖 Executing node Browser Automation node: {node_name}"
             logger.debug(log_msg)
             send_skill_editor_log("log", log_msg)
@@ -3491,9 +3480,22 @@ async def _run_browser_use(task: str, mainwin, state: dict | None = None, callin
             from config.app_settings import app_settings
             disable_extensions = app_settings.is_dev_mode
 
-            # Create browser profile with extensions control
+            # Create browser profile with extensions control and persistent user_data_dir
             # Note: BrowserProfile uses enable_default_extensions (not disable_extensions)
-            browser_profile = BrowserProfile(enable_default_extensions=not disable_extensions)
+            # Auto-assign persistent user_data_dir so login state survives restarts
+            profile_settings = _get_browser_profile_settings(node_profile)
+            _bp_user_data_dir = profile_settings.get('user_data_dir', '') if profile_settings else ''
+            if not _bp_user_data_dir:
+                from utils.user_path_helper import ensure_user_data_dir
+                import re as _re
+                _bp_id = profile_settings.get('id') or profile_settings.get('name') or node_profile or 'default'
+                _bp_safe_id = _re.sub(r'[^\w\-]', '_', str(_bp_id))
+                _bp_user_data_dir = ensure_user_data_dir(subdir=os.path.join('browser_profiles', _bp_safe_id))
+                logger.info(f"[BrowserAutomation] Auto-assigned user_data_dir: {_bp_user_data_dir}")
+            browser_profile = BrowserProfile(
+                enable_default_extensions=not disable_extensions,
+                user_data_dir=_bp_user_data_dir,
+            )
             logger.info(f"[BrowserAutomation] Extensions {'disabled (dev mode)' if disable_extensions else 'enabled (production mode)'}")
 
             if browser_profile:

agent/ec_skills/build_node.py

@@ -2071,7 +2071,8 @@ def create_browser_use_llm(mainwin=None, fallback_llm=None, skip_playwright_chec
                 # Get supports_vision from config (default True if not found)
                 supports_vision = config.get('supports_vision', True)
 
-                log_msg = f"[create_browser_use_llm] provider_type:{provider_type}, model_name:{model_name}, api_key:{api_key}, base_url:{base_url}, class_name:{class_name}, supports_vision:{supports_vision}"
+                masked_key = (api_key[:8] + '...' + api_key[-4:]) if api_key and len(api_key) > 12 else '***'
+                log_msg = f"[create_browser_use_llm] provider_type:{provider_type}, model_name:{model_name}, api_key:{masked_key}, base_url:{base_url}, class_name:{class_name}, supports_vision:{supports_vision}"
                 logger.debug(log_msg)
                 send_skill_editor_log("log", log_msg)
 

agent/ec_skills/llm_utils/llm_utils.py

@@ -120,22 +120,43 @@ def confirm_sign_up(self, username, confirmation_code):
 
     def login(self, username, password):
         import time
+        from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
         start_time = time.time()
 
+        # Overall timeout to prevent indefinite waiting (e.g., DNS/SSL delays beyond boto3's control)
+        # boto3 retries internally (max_attempts * (connect_timeout + read_timeout) ≈ 105s worst case)
+        # We add a hard ceiling of 60s to fail fast for users in high-latency networks
+        auth_flow_config = perf_config.get_auth_flow_config()
+        overall_timeout = auth_flow_config.get('total_timeout', 30)
+
         try:
             if perf_config.should_log_timing():
                 logger.info(f"Starting Cognito authentication: {username}")
 
             client = self._get_cognito_client()
 
-            response = client.initiate_auth(
-                ClientId=AuthConfig.COGNITO.CLIENT_ID,
-                AuthFlow='USER_PASSWORD_AUTH',
-                AuthParameters={
-                    'USERNAME': username,
-                    'PASSWORD': password
-                }
-            )
+            def _do_auth():
+                return client.initiate_auth(
+                    ClientId=AuthConfig.COGNITO.CLIENT_ID,
+                    AuthFlow='USER_PASSWORD_AUTH',
+                    AuthParameters={
+                        'USERNAME': username,
+                        'PASSWORD': password
+                    }
+                )
+
+            # Execute with overall timeout to prevent 185s+ waits
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                future = executor.submit(_do_auth)
+                try:
+                    response = future.result(timeout=overall_timeout)
+                except FuturesTimeoutError:
+                    elapsed_time = time.time() - start_time
+                    logger.error(f"Cognito authentication overall timeout: {username}, "
+                               f"timeout={overall_timeout}s, elapsed: {elapsed_time:.2f}s")
+                    # Reset cognito_client so next attempt creates a fresh connection
+                    self.cognito_client = None
+                    return {'success': False, 'error': f'Authentication timeout after {overall_timeout}s. Please check your network connection.'}
 
             elapsed_time = time.time() - start_time
 

auth/cognito/cognito_service.py

@@ -21,7 +21,7 @@ class AuthPerformanceConfig:
 
         # Authentication flow configuration
         'auth_flow': {
-            'total_timeout': 30,       # Total authentication timeout (seconds) - increased for stability
+            'total_timeout': 45,       # Total authentication timeout (seconds) - hard ceiling for entire auth flow
         },
 
         # Performance monitoring configuration