cnhkmcp 2.1.2__py3-none-any.whl → 2.1.4__py3-none-any.whl

cnhkmcp/untracked/mcp/321/206/320/246/320/227/321/204/342/225/227/342/225/242/321/210/320/276/342/225/221/321/205/320/255/320/253/321/207/320/231/320/2302_/321/205/320/266/320/222/321/206/320/256/320/254/321/205/320/236/320/257/321/207/320/231/320/230/321/205/320/240/320/277/321/205/320/232/320/270/321/204/342/225/225/320/235/321/204/342/225/221/320/226/321/206/342/225/241/320/237/321/210/320/267/320/230/321/205/320/251/320/270/321/205/342/226/221/342/226/222/321/210/320/277/320/245/321/210/342/224/220/320/251/321/204/342/225/225/320/272/platform_functions.py

@@ -16,6 +16,7 @@ from dataclasses import dataclass, asdict
 from datetime import datetime, timedelta
 import os
 import sys
+import math
 from time import sleep
 
 import requests
@@ -80,7 +81,20 @@ class BrainApiClient:
     
     def log(self, message: str, level: str = "INFO"):
         """Log messages to stderr to avoid MCP protocol interference."""
-        print(f"[{level}] {message}", file=sys.stderr)
+        try:
+            # Try to print with original message first
+            print(f"[{level}] {message}", file=sys.stderr)
+        except UnicodeEncodeError:
+            # Fallback: remove problematic characters and try again
+            try:
+                safe_message = message.encode('ascii', 'ignore').decode('ascii')
+                print(f"[{level}] {safe_message}", file=sys.stderr)
+            except Exception:
+                # Final fallback: just print the level and a safe message
+                print(f"[{level}] Log message", file=sys.stderr)
+        except Exception:
+            # Final fallback: just print the level and a safe message
+            print(f"[{level}] Log message", file=sys.stderr)
     
     async def authenticate(self, email: str, password: str) -> Dict[str, Any]:
         """Authenticate with WorldQuant BRAIN platform with biometric support."""
@@ -322,7 +336,9 @@ class BrainApiClient:
             print("Alpha done simulating, getting alpha details")
             alpha_id = simulation_progress.json()["alpha"]
             alpha = self.session.get("https://api.worldquantbrain.com/alphas/" + alpha_id)
-            return alpha.json()
+            result = alpha.json()
+            result['note'] = "if you got a negative alpha sharpe, you can just add a minus sign in front of the last line of the Alpha to flip then think the next step."
+            return result
             
         except Exception as e:
             self.log(f"❌ Failed to create simulation: {str(e)}", "ERROR")
@@ -414,12 +430,13 @@ class BrainApiClient:
                 response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/pnl")
                 response.raise_for_status()
                 
+                # Some alphas may return 204 No Content or an empty body
                 text = (response.text or "").strip()
                 if not text:
                     if attempt < max_retries - 1:
                         self.log(f"Empty PnL response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
                         await asyncio.sleep(retry_delay)
-                        retry_delay *= 1.5
+                        retry_delay *= 1.5  # Exponential backoff
                         continue
                     else:
                         self.log(f"Empty PnL response after {max_retries} attempts for {alpha_id}", "WARNING")
@@ -440,7 +457,7 @@ class BrainApiClient:
                             self.log(f"Empty PnL JSON after {max_retries} attempts for {alpha_id}", "WARNING")
                             return {}
                             
-                except json.JSONDecodeError as parse_err:
+                except Exception as parse_err:
                     if attempt < max_retries - 1:
                         self.log(f"PnL JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
                         await asyncio.sleep(retry_delay)
@@ -450,7 +467,7 @@ class BrainApiClient:
                         self.log(f"PnL JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
                         return {}
                         
-            except requests.RequestException as e:
+            except Exception as e:
                 if attempt < max_retries - 1:
                     self.log(f"Failed to get alpha PnL for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
                     await asyncio.sleep(retry_delay)
@@ -460,6 +477,7 @@ class BrainApiClient:
                     self.log(f"Failed to get alpha PnL for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
                     raise
         
+        # This should never be reached, but just in case
         return {}
     
     async def get_user_alphas(
@@ -508,12 +526,17 @@ class BrainApiClient:
         await self.ensure_authenticated()
         
         try:
+            self.log(f"📤 Submitting alpha {alpha_id} for production...", "INFO")
+            
             response = self.session.post(f"{self.base_url}/alphas/{alpha_id}/submit")
             response.raise_for_status()
-            return True
+            
+            self.log(f"Alpha {alpha_id} submitted successfully", "SUCCESS")
+            return response.__dict__
+            
         except Exception as e:
-            self.log(f"Failed to submit alpha: {str(e)}", "ERROR")
-            raise
+            self.log(f"❌ Failed to submit alpha: {str(e)}", "ERROR")
+            return False
     
     async def get_events(self) -> Dict[str, Any]:
         """Get available events and competitions."""
@@ -701,7 +724,13 @@ class BrainApiClient:
         try:
             response = self.session.get(f"{self.base_url}/operators")
             response.raise_for_status()
-            return response.json()
+            operators_data = response.json()
+            
+            # Ensure we return a dictionary format even if API returns a list
+            if isinstance(operators_data, list):
+                return {"operators": operators_data, "count": len(operators_data)}
+            else:
+                return operators_data
         except Exception as e:
             self.log(f"Failed to get operators: {str(e)}", "ERROR")
             raise
@@ -761,85 +790,135 @@ class BrainApiClient:
             
     async def get_messages(self, limit: Optional[int] = None, offset: int = 0) -> Dict[str, Any]:
         """Get messages for the current user with optional pagination.
-        
-        This function retrieves messages, processes their descriptions to extract
-        and format embedded JSON, and handles file attachments by saving them locally.
+
+        Image / large binary payload mitigation:
+          Some messages embed base64 encoded images (e.g. <img src="data:image/png;base64,..."/>).
+          Returning full base64 can explode token usage for an LLM client. We post-process each
+          message description and (by default) extract embedded base64 images to disk and replace
+          them with lightweight placeholders while preserving context.
+
+        Strategies (environment driven in future – currently parameterless public API):
+          - placeholder (default): save images to message_images/ and replace with marker text.
+          - ignore: strip image tags entirely, leaving a note.
+          - keep: leave description unchanged (unsafe for LLM token limits).
+
+        A message dict gains an 'extracted_images' list when images are processed.
         """
+        await self.ensure_authenticated()
+
+        import re, base64, pathlib
+
+        image_handling = os.environ.get("BRAIN_MESSAGE_IMAGE_MODE", "placeholder").lower()
+        save_dir = pathlib.Path("message_images")
+
         from typing import Tuple
-        
         def process_description(desc: str, message_id: str) -> Tuple[str, List[str]]:
-            """
-            Processes message description to handle HTML, embedded images, and JSON.
-            """
-            attachments = []
-            
-            # Handle embedded images
-            soup = BeautifulSoup(desc, 'html.parser')
-            for idx, img_tag in enumerate(soup.find_all('img')):
-                src = img_tag.get('src', '')
-                if src.startswith('data:image'):
+            try:
+                if not desc or image_handling == "keep":
+                    return desc, []
+                attachments: List[str] = []
+                # Regex to capture full <img ...> tag with data URI
+                img_tag_pattern = re.compile(r"<img[^>]+src=\"(data:image/[^\"]+)\"[^>]*>", re.IGNORECASE)
+                # Iterate over unique matches to avoid double work
+                matches = list(img_tag_pattern.finditer(desc))
+                if not matches:
+                    # Additional heuristic: very long base64-looking token inside quotes followed by </img>
+                    # (legacy format noted by user sample). Replace with placeholder.
+                    heuristic_pattern = re.compile(r"([A-Za-z0-9+/]{500,}={0,2})\"\s*</img>")
+                    if image_handling != "keep" and heuristic_pattern.search(desc):
+                        placeholder = "[Embedded image removed - large base64 sequence truncated]"
+                        return heuristic_pattern.sub(placeholder + "</img>", desc), []
+                    return desc, []
+
+                # Ensure save directory exists only if we will store something
+                if image_handling == "placeholder" and not save_dir.exists():
                     try:
-                        # Extract image data
-                        header, encoded = src.split(',', 1)
-                        ext = header.split(';')[0].split('/')[1]
-                        safe_ext = re.sub(r'[^a-zA-Z0-9]', '', ext)
-                        
-                        # Decode and save image
-                        content = base64.b64decode(encoded)
-                        file_name = f"{message_id}_img_{idx}.{safe_ext}"
-                        with open(file_name, "wb") as f:
-                            f.write(content)
-                        
-                        # Update HTML and add attachment info
-                        img_tag['src'] = file_name
-                        attachments.append(f"Saved embedded image to ./{file_name}")
-                        
+                        save_dir.mkdir(parents=True, exist_ok=True)
                     except Exception as e:
-                        attachments.append(f"Could not process embedded image: {e}")
-            
-            desc = str(soup)
+                        self.log(f"Could not create image save directory: {e}", "WARNING")
 
-            # Handle JSON content
-            try:
-                json_part_match = re.search(r'```json\n({.*?})\n```', desc, re.DOTALL)
-                if json_part_match:
-                    json_str = json_part_match.group(1)
-                    desc = desc.replace(json_part_match.group(0), "").strip()
-                    
-                    try:
-                        data = json.loads(json_str)
-                        formatted_json = json.dumps(data, indent=2)
-                        desc += f"\n\n---\n**Details**\n```json\n{formatted_json}\n```"
-                    except json.JSONDecodeError:
-                        desc += f"\n\n---\n**Details (raw)**\n{json_str}"
-            except Exception:
-                pass
-                
-            return desc, attachments
+                new_desc = desc
+                for idx, match in enumerate(matches, start=1):
+                    data_uri = match.group(1)  # data:image/...;base64,XXXX
+                    if not data_uri.lower().startswith("data:image"):
+                        continue
+                    # Split header and base64 payload
+                    if "," not in data_uri:
+                        continue
+                    header, b64_data = data_uri.split(",", 1)
+                    mime_part = header.split(";")[0]  # data:image/png
+                    ext = "png"
+                    if "/" in mime_part:
+                        ext = mime_part.split("/")[1]
+                    safe_ext = (ext or "img").split("?")[0]
+                    placeholder_text = "[Embedded image]"
+                    if image_handling == "ignore":
+                        replacement = f"[Image removed: {safe_ext}]"
+                    elif image_handling == "placeholder":
+                        # Try decode & save
+                        file_name = f"{message_id}_{idx}.{safe_ext}"
+                        file_path = save_dir / file_name
+                        try:
+                            # Guard extremely large strings (>5MB ~ 6.7M base64 chars) to avoid memory blow
+                            if len(b64_data) > 7_000_000:
+                                raise ValueError("Image too large to decode safely")
+                            with open(file_path, "wb") as f:
+                                f.write(base64.b64decode(b64_data))
+                            attachments.append(str(file_path))
+                            replacement = f"[Image extracted -> {file_path}]"
+                        except Exception as e:
+                            self.log(f"Failed to decode embedded image in message {message_id}: {e}", "WARNING")
+                            replacement = "[Image extraction failed - content omitted]"
+                    else:  # keep
+                        replacement = placeholder_text  # shouldn't be used since early return, but safe
+                    # Replace only the matched tag (not global) – use re.sub with count=1 on substring slice
+                    # Safer to operate on new_desc using the exact matched string
+                    original_tag = match.group(0)
+                    new_desc = new_desc.replace(original_tag, replacement, 1)
+                return new_desc, attachments
+            except UnicodeEncodeError as ue:
+                self.log(f"Unicode encoding error in process_description: {ue}", "WARNING")
+                return desc, []
+            except Exception as e:
+                self.log(f"Error in process_description: {e}", "WARNING")
+                return desc, []
 
-        await self.ensure_authenticated()
-        
         try:
-            params = {"limit": limit, "offset": offset}
-            params = {k: v for k, v in params.items() if v is not None}
-            
+            params = {}
+            if limit is not None:
+                params['limit'] = limit
+            if offset > 0:
+                params['offset'] = offset
+
             response = self.session.get(f"{self.base_url}/users/self/messages", params=params)
             response.raise_for_status()
-            messages_data = response.json()
-            
-            # Process descriptions and attachments
-            for msg in messages_data.get("results", []):
-                try:
-                    msg_id = msg.get("id", "unknown_id")
-                    new_desc, attachments = process_description(msg.get("description", ""), msg_id)
-                    msg["description"] = new_desc
-                    if attachments:
-                        msg["attachments_info"] = attachments
-                except Exception as e:
-                    self.log(f"Error processing message {msg.get('id')}: {e}", "ERROR")
+            data = response.json()
 
-            return messages_data
-            
+            # Post-process results for image handling
+            results = data.get('results', [])
+            for msg in results:
+                try:
+                    desc = msg.get('description')
+                    processed_desc, attachments = process_description(desc, msg.get('id', 'msg'))
+                    if attachments or desc != processed_desc:
+                        msg['description'] = processed_desc
+                        if attachments:
+                            msg['extracted_images'] = attachments
+                        else:
+                            # If changed but no attachments (ignore mode) mark sanitized
+                            msg['sanitized'] = True
+                except UnicodeEncodeError as ue:
+                    self.log(f"Unicode encoding error sanitizing message {msg.get('id')}: {ue}", "WARNING")
+                    # Keep original description if encoding fails
+                    continue
+                except Exception as inner_e:
+                    self.log(f"Failed to sanitize message {msg.get('id')}: {inner_e}", "WARNING")
+            data['results'] = results
+            data['image_handling'] = image_handling
+            return data
+        except UnicodeEncodeError as ue:
+            self.log(f"Failed to get messages due to encoding error: {str(ue)}", "ERROR")
+            raise
         except Exception as e:
             self.log(f"Failed to get messages: {str(e)}", "ERROR")
             raise
@@ -871,11 +950,11 @@ class BrainApiClient:
             raise
     
     async def get_alpha_yearly_stats(self, alpha_id: str) -> Dict[str, Any]:
-        """Get yearly statistics for an alpha."""
+        """Get yearly statistics for an alpha with retry logic."""
         await self.ensure_authenticated()
         
         max_retries = 5
-        retry_delay = 2
+        retry_delay = 2  # seconds
         
         for attempt in range(max_retries):
             try:
@@ -884,55 +963,62 @@ class BrainApiClient:
                 response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/yearly-stats")
                 response.raise_for_status()
                 
+                # Check if response has content
                 text = (response.text or "").strip()
                 if not text:
                     if attempt < max_retries - 1:
-                        self.log(f"Empty yearly stats response for {alpha_id}, retrying...", "WARNING")
+                        self.log(f"Empty yearly stats response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
                         await asyncio.sleep(retry_delay)
-                        retry_delay *= 1.5
+                        retry_delay *= 1.5  # Exponential backoff
                         continue
                     else:
+                        self.log(f"Empty yearly stats response after {max_retries} attempts for {alpha_id}", "WARNING")
                         return {}
                 
                 try:
-                    stats_data = response.json()
-                    if stats_data:
-                        return stats_data
+                    yearly_stats = response.json()
+                    if yearly_stats:
+                        self.log(f"Successfully retrieved yearly stats for alpha {alpha_id}", "SUCCESS")
+                        return yearly_stats
                     else:
                         if attempt < max_retries - 1:
-                            self.log(f"Empty yearly stats JSON for {alpha_id}, retrying...", "WARNING")
+                            self.log(f"Empty yearly stats JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
                             await asyncio.sleep(retry_delay)
                             retry_delay *= 1.5
                             continue
                         else:
+                            self.log(f"Empty yearly stats JSON after {max_retries} attempts for {alpha_id}", "WARNING")
                             return {}
                             
-                except json.JSONDecodeError as parse_err:
+                except Exception as parse_err:
                     if attempt < max_retries - 1:
-                        self.log(f"Yearly stats JSON parse failed for {alpha_id}, retrying...", "WARNING")
+                        self.log(f"Yearly stats JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
                         await asyncio.sleep(retry_delay)
                         retry_delay *= 1.5
                         continue
                     else:
-                        raise
+                        self.log(f"Yearly stats JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
                         
-            except requests.RequestException as e:
+            except Exception as e:
                 if attempt < max_retries - 1:
-                    self.log(f"Failed to get yearly stats for {alpha_id}, retrying: {e}", "WARNING")
+                    self.log(f"Failed to get alpha yearly stats for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
                     await asyncio.sleep(retry_delay)
                     retry_delay *= 1.5
                     continue
                 else:
+                    self.log(f"Failed to get alpha yearly stats for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
                     raise
         
+        # This should never be reached, but just in case
         return {}
         
     async def get_production_correlation(self, alpha_id: str) -> Dict[str, Any]:
-        """Get production correlation data for an alpha."""
+        """Get production correlation data for an alpha with retry logic."""
         await self.ensure_authenticated()
         
         max_retries = 5
-        retry_delay = 2
+        retry_delay = 20  # seconds
         
         for attempt in range(max_retries):
             try:
@@ -953,44 +1039,46 @@ class BrainApiClient:
                         return {}
                 
                 try:
-                    corr_data = response.json()
-                    if corr_data:
-                        return corr_data
+                    correlation_data = response.json()
+                    if correlation_data:
+                        self.log(f"Successfully retrieved production correlation for alpha {alpha_id}", "SUCCESS")
+                        return correlation_data
                     else:
                         if attempt < max_retries - 1:
-                            self.log(f"Empty production correlation JSON for {alpha_id}, retrying...", "WARNING")
+                            self.log(f"Empty production correlation JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
                             await asyncio.sleep(retry_delay)
-                            retry_delay *= 1.5
                             continue
                         else:
+                            self.log(f"Empty production correlation JSON after {max_retries} attempts for {alpha_id}", "WARNING")
                             return {}
                             
-                except json.JSONDecodeError:
+                except Exception as parse_err:
                     if attempt < max_retries - 1:
-                        self.log(f"Production correlation JSON parse failed for {alpha_id}, retrying...", "WARNING")
+                        self.log(f"Production correlation JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
                         await asyncio.sleep(retry_delay)
-                        retry_delay *= 1.5
                         continue
                     else:
-                        raise
+                        self.log(f"Production correlation JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
                         
-            except requests.RequestException as e:
+            except Exception as e:
                 if attempt < max_retries - 1:
-                    self.log(f"Failed to get production correlation for {alpha_id}, retrying: {e}", "WARNING")
+                    self.log(f"Failed to get production correlation for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
                     await asyncio.sleep(retry_delay)
-                    retry_delay *= 1.5
                     continue
                 else:
+                    self.log(f"Failed to get production correlation for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
                     raise
         
+        # This should never be reached, but just in case
         return {}
 
     async def get_self_correlation(self, alpha_id: str) -> Dict[str, Any]:
-        """Get self correlation data for an alpha."""
+        """Get self-correlation data for an alpha with retry logic."""
         await self.ensure_authenticated()
         
         max_retries = 5
-        retry_delay = 2
+        retry_delay = 20  # seconds
         
         for attempt in range(max_retries):
             try:
@@ -1011,36 +1099,38 @@ class BrainApiClient:
                         return {}
                 
                 try:
-                    corr_data = response.json()
-                    if corr_data:
-                        return corr_data
+                    correlation_data = response.json()
+                    if correlation_data:
+                        self.log(f"Successfully retrieved self correlation for alpha {alpha_id}", "SUCCESS")
+                        return correlation_data
                     else:
                         if attempt < max_retries - 1:
-                            self.log(f"Empty self correlation JSON for {alpha_id}, retrying...", "WARNING")
+                            self.log(f"Empty self correlation JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
                             await asyncio.sleep(retry_delay)
-                            retry_delay *= 1.5
                             continue
                         else:
+                            self.log(f"Empty self correlation JSON after {max_retries} attempts for {alpha_id}", "WARNING")
                             return {}
                             
-                except json.JSONDecodeError:
+                except Exception as parse_err:
                     if attempt < max_retries - 1:
-                        self.log(f"Self correlation JSON parse failed for {alpha_id}, retrying...", "WARNING")
+                        self.log(f"Self correlation JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
                         await asyncio.sleep(retry_delay)
-                        retry_delay *= 1.5
                         continue
                     else:
-                        raise
+                        self.log(f"Self correlation JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
                         
-            except requests.RequestException as e:
+            except Exception as e:
                 if attempt < max_retries - 1:
-                    self.log(f"Failed to get self correlation for {alpha_id}, retrying: {e}", "WARNING")
+                    self.log(f"Failed to get self correlation for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
                     await asyncio.sleep(retry_delay)
-                    retry_delay *= 1.5
                     continue
                 else:
+                    self.log(f"Failed to get self correlation for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
                     raise
         
+        # This should never be reached, but just in case
         return {}
 
     async def check_correlation(self, alpha_id: str, correlation_type: str = "both", threshold: float = 0.7) -> Dict[str, Any]:
@@ -1048,22 +1138,84 @@ class BrainApiClient:
         await self.ensure_authenticated()
         
         try:
-            results = {}
-            if correlation_type in ["production", "both"]:
-                results["production"] = await self.get_production_correlation(alpha_id)
-            if correlation_type in ["self", "both"]:
-                results["self"] = await self.get_self_correlation(alpha_id)
-            
-            # Add analysis based on threshold
-            for key, data in results.items():
-                if "correlation" in data and "sharpe" in data["correlation"]:
-                    high_corr = [item for item in data["correlation"]["sharpe"] if abs(item.get("corr", 0)) > threshold]
-                    data["analysis"] = {
-                        "highly_correlated_count": len(high_corr),
-                        "highly_correlated_alphas": high_corr
-                    }
+            results = {
+                'alpha_id': alpha_id,
+                'threshold': threshold,
+                'correlation_type': correlation_type,
+                'checks': {}
+            }
+            
+            # Determine which correlations to check
+            check_types = []
+            if correlation_type == "both":
+                check_types = ["production", "self"]
+            else:
+                check_types = [correlation_type]
+            
+            all_passed = True
+            
+            for check_type in check_types:
+                if check_type == "production":
+                    correlation_data = await self.get_production_correlation(alpha_id)
+                elif check_type == "self":
+                    correlation_data = await self.get_self_correlation(alpha_id)
+                else:
+                    continue
+                
+                # Analyze correlation data (robust to schema/records format)
+                if isinstance(correlation_data, dict):
+                    # Prefer strict access to schema.max or top-level max; otherwise error
+                    schema = correlation_data.get('schema') or {}
+                    if isinstance(schema, dict) and 'max' in schema:
+                        max_correlation = float(schema['max'])
+                    elif 'max' in correlation_data:
+                        # Some endpoints place max at top-level
+                        max_correlation = float(correlation_data['max'])
+                    else:
+                        # Attempt to derive from records; if none found, raise error instead of defaulting
+                        records = correlation_data.get('records') or []
+                        if isinstance(records, list) and records:
+                            candidate_max = None
+                            for row in records:
+                                if isinstance(row, (list, tuple)):
+                                    for v in row:
+                                        try:
+                                            vf = float(v)
+                                            if -1.0 <= vf <= 1.0:
+                                                candidate_max = vf if candidate_max is None else max(candidate_max, vf)
+                                        except Exception:
+                                            continue
+                                elif isinstance(row, dict):
+                                    for key in ('correlation', 'prodCorrelation', 'selfCorrelation', 'max'):
+                                        try:
+                                            vf = float(row.get(key))
+                                            if -1.0 <= vf <= 1.0:
+                                                candidate_max = vf if candidate_max is None else max(candidate_max, vf)
+                                        except Exception:
+                                            continue
+                            if candidate_max is None:
+                                raise ValueError("Unable to derive max correlation from records")
+                            max_correlation = float(candidate_max)
+                        else:
+                            raise KeyError("Correlation response missing 'schema.max' or top-level 'max' and no 'records' to derive from")
+                else:
+                    raise TypeError("Correlation data is not a dictionary")
 
+                passes_check = max_correlation < threshold
+                
+                results['checks'][check_type] = {
+                    'max_correlation': max_correlation,
+                    'passes_check': passes_check,
+                    'correlation_data': correlation_data
+                }
+                
+                if not passes_check:
+                    all_passed = False
+            
+            results['all_passed'] = all_passed
+            
             return results
+            
         except Exception as e:
             self.log(f"Failed to check correlation: {str(e)}", "ERROR")
             raise
@@ -1073,20 +1225,22 @@ class BrainApiClient:
         await self.ensure_authenticated()
         
         try:
-            # This endpoint might not exist, so we simulate it by calling other functions
-            # In a real scenario, this would be a single API call
+            # Get correlation checks using the unified function
+            correlation_checks = await self.check_correlation(alpha_id, correlation_type="both")
             
-            pnl_data = await self.get_alpha_pnl(alpha_id)
-            yearly_stats = await self.get_alpha_yearly_stats(alpha_id)
-            correlation = await self.check_correlation(alpha_id)
+            # Get alpha details for additional validation
+            alpha_details = await self.get_alpha_details(alpha_id)
             
-            return {
-                "pnl_summary": pnl_data.get("pnlSummary", {}),
-                "yearly_stats": yearly_stats,
-                "correlation": correlation
+            # Compile comprehensive check results
+            checks = {
+                'correlation_checks': correlation_checks,
+                'alpha_details': alpha_details,
+                'all_passed': correlation_checks['all_passed']
             }
+            
+            return checks
         except Exception as e:
-            self.log(f"Failed submission check: {str(e)}", "ERROR")
+            self.log(f"Failed to get submission check: {str(e)}", "ERROR")
             raise
 
     async def set_alpha_properties(self, alpha_id: str, name: Optional[str] = None, 
@@ -1096,18 +1250,19 @@ class BrainApiClient:
         await self.ensure_authenticated()
         
         try:
-            payload = {
-                "name": name,
-                "color": color,
-                "tags": tags,
-                "descriptions": {
-                    "selection": selection_desc,
-                    "combo": combo_desc
-                }
-            }
-            payload = {k: v for k, v in payload.items() if v is not None}
+            data = {}
+            if name:
+                data['name'] = name
+            if color:
+                data['color'] = color
+            if tags:
+                data['tags'] = tags
+            if selection_desc:
+                data['selectionDesc'] = selection_desc
+            if combo_desc:
+                data['comboDesc'] = combo_desc
             
-            response = self.session.patch(f"{self.base_url}/alphas/{alpha_id}", json=payload)
+            response = self.session.patch(f"{self.base_url}/alphas/{alpha_id}", json=data)
             response.raise_for_status()
             return response.json()
         except Exception as e:
@@ -1174,11 +1329,35 @@ class BrainApiClient:
         try:
             params = {}
             if start_date:
-                params["startDate"] = start_date
+                params['startDate'] = start_date
             if end_date:
-                params["endDate"] = end_date
-                
+                params['endDate'] = end_date
+            
+            # Try the user-specific activities endpoint first (like pyramid-multipliers)
             response = self.session.get(f"{self.base_url}/users/self/activities/pyramid-alphas", params=params)
+            
+            # If that fails, try alternative endpoints
+            if response.status_code == 404:
+                # Try alternative endpoint structure
+                response = self.session.get(f"{self.base_url}/users/self/pyramid/alphas", params=params)
+                
+                if response.status_code == 404:
+                    # Try yet another alternative
+                    response = self.session.get(f"{self.base_url}/activities/pyramid-alphas", params=params)
+                    
+                    if response.status_code == 404:
+                        # Return an informative error with what we tried
+                        return {
+                            "error": "Pyramid alphas endpoint not found",
+                            "tried_endpoints": [
+                                "/users/self/activities/pyramid-alphas",
+                                "/users/self/pyramid/alphas", 
+                                "/activities/pyramid-alphas",
+                                "/pyramid/alphas"
+                            ],
+                            "suggestion": "This endpoint may not be available in the current API version"
+                        }
+            
             response.raise_for_status()
             return response.json()
         except Exception as e:
@@ -1451,20 +1630,27 @@ async def manage_config(action: str = "get", settings: Optional[Dict[str, Any]]
     Returns:
         Current or updated configuration including authentication status
     """
-    config = load_config()
+    if action == "get":
+        config = load_config()
+        auth_status = await brain_client.get_authentication_status()
+        
+        return {
+            "config": config,
+            "auth_status": auth_status,
+            "is_authenticated": await brain_client.is_authenticated()
+        }
     
-    if action == "set" and settings:
+    elif action == "set":
+        if settings is None:
+            return {"error": "Settings parameter is required when action='set'"}
+        
+        config = load_config()
         config.update(settings)
         save_config(config)
-        
-    is_authed = await brain_client.is_authenticated()
-    config['isAuthenticated'] = is_authed
+        return config
     
-    # Mask password for security
-    if 'password' in config:
-        config['password'] = '********'
-        
-    return config
+    else:
+        return {"error": f"Invalid action '{action}'. Use 'get' or 'set'."}
 
 # --- Simulation Tools ---