fixed

Author: rcholic

sentience/agent.py

@@ -830,7 +830,9 @@ async def act(  # noqa: C901
                     snap_opts.goal = goal
 
                 # Apply AgentConfig screenshot settings if not overridden by snapshot_options
-                if snapshot_options is None and self.config:
+                # Only apply if snapshot_options wasn't provided OR if screenshot wasn't explicitly set
+                # (snapshot_options.screenshot defaults to False, so we check if it's still False)
+                if self.config and (snapshot_options is None or snap_opts.screenshot is False):
                     if self.config.capture_screenshots:
                         # Create ScreenshotConfig from AgentConfig
                         snap_opts.screenshot = ScreenshotConfig(

sentience/cloud_tracing.py

@@ -181,7 +181,6 @@ def _do_upload(self, on_progress: Callable[[int, int], None] | None = None) -> N
 
             # Step 2: Upload screenshots separately
             if screenshots:
-                print(f"📸 [Sentience] Uploading {len(screenshots)} screenshots...")
                 self._upload_screenshots(screenshots, on_progress)
 
             # Step 3: Create cleaned trace file (without screenshot_base64)
@@ -505,16 +504,31 @@ def _request_screenshot_urls(self, sequences: list[int]) -> dict[int, str]:
                 data = response.json()
                 # Gateway returns sequences as strings in JSON, convert to int keys
                 upload_urls = data.get("upload_urls", {})
-                return {int(k): v for k, v in upload_urls.items()}
+                result = {int(k): v for k, v in upload_urls.items()}
+                if self.logger:
+                    self.logger.info(f"Received {len(result)} screenshot upload URLs")
+                return result
             else:
+                error_msg = f"Failed to get screenshot URLs: HTTP {response.status_code}"
                 if self.logger:
-                    self.logger.warning(
-                        f"Failed to get screenshot URLs: HTTP {response.status_code}"
-                    )
+                    self.logger.warning(error_msg)
+                else:
+                    print(f"   ⚠️  {error_msg}")
+                # Try to get error details
+                try:
+                    error_data = response.json()
+                    error_detail = error_data.get("error") or error_data.get("message", "")
+                    if error_detail:
+                        print(f"      Error: {error_detail}")
+                except Exception:
+                    print(f"      Response: {response.text[:200]}")
                 return {}
         except Exception as e:
+            error_msg = f"Error requesting screenshot URLs: {e}"
             if self.logger:
-                self.logger.warning(f"Error requesting screenshot URLs: {e}")
+                self.logger.warning(error_msg)
+            else:
+                print(f"   ⚠️  {error_msg}")
             return {}
 
     def _upload_screenshots(
@@ -540,11 +554,18 @@ def _upload_screenshots(
 
         # 1. Request pre-signed URLs from gateway
         sequences = sorted(screenshots.keys())
+        print(f"   Requesting upload URLs for {len(sequences)} screenshot(s)...")
         upload_urls = self._request_screenshot_urls(sequences)
 
         if not upload_urls:
             print("⚠️  [Sentience] No screenshot upload URLs received, skipping upload")
+            print("   This may indicate:")
+            print("   - API key doesn't have permission for screenshot uploads")
+            print("   - Gateway endpoint /v1/screenshots/init returned an error")
+            print("   - Network issue connecting to gateway")
             return
+        
+        print(f"   ✅ Received {len(upload_urls)} upload URL(s) from gateway")
 
         # 2. Upload screenshots in parallel
         uploaded_count = 0
@@ -566,6 +587,11 @@ def upload_one(seq: int, url: str) -> bool:
                 self.screenshot_total_size_bytes += image_size
 
                 # Upload to pre-signed URL
+                # Extract the base URL for logging (without query params)
+                upload_base_url = url.split('?')[0] if '?' in url else url
+                if self.verbose if hasattr(self, 'verbose') else False:
+                    print(f"   📤 Uploading screenshot {seq} ({image_size / 1024:.1f} KB) to: {upload_base_url[:80]}...")
+                
                 response = requests.put(
                     url,
                     data=image_bytes,  # Binary image data
@@ -576,16 +602,34 @@ def upload_one(seq: int, url: str) -> bool:
                 )
 
                 if response.status_code == 200:
+                    if self.logger:
+                        self.logger.info(f"Screenshot {seq} uploaded successfully ({image_size / 1024:.1f} KB)")
+                    else:
+                        # Extract base URL for logging (without query params for security)
+                        upload_base = url.split('?')[0] if '?' in url else url
+                        upload_base_short = upload_base[:80] + "..." if len(upload_base) > 80 else upload_base
+                        print(f"   ✅ Screenshot {seq} uploaded: {image_size / 1024:.1f} KB, format={format_str}, URL={upload_base_short}")
                     return True
                 else:
+                    error_msg = f"Screenshot {seq} upload failed: HTTP {response.status_code}"
                     if self.logger:
-                        self.logger.warning(
-                            f"Screenshot {seq} upload failed: HTTP {response.status_code}"
-                        )
+                        self.logger.warning(error_msg)
+                    else:
+                        print(f"   ⚠️  {error_msg}")
+                    # Try to get error details from response
+                    try:
+                        error_detail = response.text[:200]
+                        if error_detail:
+                            print(f"      Response: {error_detail}")
+                    except Exception:
+                        pass
                     return False
             except Exception as e:
+                error_msg = f"Screenshot {seq} upload error: {e}"
                 if self.logger:
-                    self.logger.warning(f"Screenshot {seq} upload error: {e}")
+                    self.logger.warning(error_msg)
+                else:
+                    print(f"   ⚠️  {error_msg}")
                 return False
 
         # Upload in parallel (max 10 concurrent)
@@ -605,7 +649,10 @@ def upload_one(seq: int, url: str) -> bool:
 
         # 3. Report results
         if uploaded_count == total_count:
-            print(f"✅ [Sentience] All {total_count} screenshots uploaded successfully")
+            total_size_mb = self.screenshot_total_size_bytes / 1024 / 1024
+            print(f"✅ [Sentience] All {total_count} screenshots uploaded successfully!")
+            print(f"   📊 Total screenshot size: {total_size_mb:.2f} MB")
+            print(f"   📸 Screenshots are now available in cloud storage")
         else:
             print(f"⚠️  [Sentience] Uploaded {uploaded_count}/{total_count} screenshots")
             if failed_sequences:

sentience/snapshot.py

@@ -380,6 +380,8 @@ async def _snapshot_via_extension_async(
         """,
         ext_options,
     )
+        if result.get("error"):
+            print(f"      Snapshot error: {result.get('error')}")
 
     # Save trace if requested
     if options.save_trace:
@@ -400,6 +402,16 @@ async def _snapshot_via_extension_async(
                 raw_elements,
             )
 
+    # Extract screenshot_format from data URL if not provided by extension
+    if result.get("screenshot") and not result.get("screenshot_format"):
+        screenshot_data_url = result.get("screenshot", "")
+        if screenshot_data_url.startswith("data:image/"):
+            # Extract format from "data:image/jpeg;base64,..." or "data:image/png;base64,..."
+            format_match = screenshot_data_url.split(";")[0].split("/")[-1]
+            if format_match in ["jpeg", "jpg", "png"]:
+                result["screenshot_format"] = "jpeg" if format_match in ["jpeg", "jpg"] else "png"
+    
+
     # Validate and parse with Pydantic
     snapshot_obj = Snapshot(**result)
     return snapshot_obj
@@ -429,10 +441,16 @@ async def _snapshot_via_api_async(
             "Sentience extension failed to inject. Cannot collect raw data for API processing."
         ) from e
 
-    # Step 1: Get raw data from local extension
+    # Step 1: Get raw data from local extension (including screenshot)
     raw_options: dict[str, Any] = {}
+    screenshot_requested = False
     if options.screenshot is not False:
-        raw_options["screenshot"] = options.screenshot
+        screenshot_requested = True
+        # Serialize ScreenshotConfig to dict if it's a Pydantic model
+        if hasattr(options.screenshot, "model_dump"):
+            raw_options["screenshot"] = options.screenshot.model_dump()
+        else:
+            raw_options["screenshot"] = options.screenshot
 
     raw_result = await browser.page.evaluate(
         """
@@ -442,6 +460,16 @@ async def _snapshot_via_api_async(
         """,
         raw_options,
     )
+    
+    # Extract screenshot from raw result (extension captures it, but API doesn't return it)
+    screenshot_data_url = raw_result.get("screenshot")
+    screenshot_format = None
+    if screenshot_data_url:
+        # Extract format from data URL
+        if screenshot_data_url.startswith("data:image/"):
+            format_match = screenshot_data_url.split(";")[0].split("/")[-1]
+            if format_match in ["jpeg", "jpg", "png"]:
+                screenshot_format = "jpeg" if format_match in ["jpeg", "jpg"] else "png"
 
     # Save trace if requested
     if options.save_trace:
@@ -487,15 +515,22 @@ async def _snapshot_via_api_async(
             response.raise_for_status()
             api_result = response.json()
 
+        # Extract screenshot format from data URL if not provided
+        if screenshot_data_url and not screenshot_format:
+            if screenshot_data_url.startswith("data:image/"):
+                format_match = screenshot_data_url.split(";")[0].split("/")[-1]
+                if format_match in ["jpeg", "jpg", "png"]:
+                    screenshot_format = "jpeg" if format_match in ["jpeg", "jpg"] else "png"
+        
         # Merge API result with local data
         snapshot_data = {
             "status": api_result.get("status", "success"),
             "timestamp": api_result.get("timestamp"),
             "url": api_result.get("url", raw_result.get("url", "")),
             "viewport": api_result.get("viewport", raw_result.get("viewport")),
             "elements": api_result.get("elements", []),
-            "screenshot": raw_result.get("screenshot"),
-            "screenshot_format": raw_result.get("screenshot_format"),
+            "screenshot": screenshot_data_url,  # Use the extracted screenshot
+            "screenshot_format": screenshot_format,  # Use the extracted format
             "error": api_result.get("error"),
         }
 

sentience/tracer_factory.py

@@ -74,19 +74,25 @@ def create_tracer(
     if api_key and upload_trace:
         try:
             # Request pre-signed upload URL from backend
+            print(f"🔗 [Sentience] Attempting to initialize cloud tracing...")
+            print(f"   API URL: {api_url}/v1/traces/init")
+            print(f"   Run ID: {run_id}")
+            
             response = requests.post(
                 f"{api_url}/v1/traces/init",
                 headers={"Authorization": f"Bearer {api_key}"},
                 json={"run_id": run_id},
                 timeout=10,
             )
 
+            print(f"   Response Status: HTTP {response.status_code}")
+
             if response.status_code == 200:
                 data = response.json()
                 upload_url = data.get("upload_url")
 
                 if upload_url:
-                    print("☁️  [Sentience] Cloud tracing enabled (Pro tier)")
+                    print("☁️  [Sentience] Cloud tracing enabled")
                     return Tracer(
                         run_id=run_id,
                         sink=CloudTraceSink(
@@ -99,13 +105,41 @@ def create_tracer(
                     )
                 else:
                     print("⚠️  [Sentience] Cloud init response missing upload_url")
+                    print(f"   Response data: {data}")
                     print("   Falling back to local-only tracing")
 
             elif response.status_code == 403:
-                print("⚠️  [Sentience] Cloud tracing requires Pro tier")
+                print("⚠️  [Sentience] Cloud tracing requires Pro/Enterprise tier")
+                print("   Your account tier may not support cloud tracing")
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error") or error_data.get("message", "")
+                    if error_msg:
+                        print(f"   API Error: {error_msg}")
+                except Exception:
+                    pass
+                print("   Falling back to local-only tracing")
+            elif response.status_code == 401:
+                print("⚠️  [Sentience] Cloud init failed: HTTP 401 Unauthorized")
+                print("   API key is invalid or expired")
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error") or error_data.get("message", "")
+                    if error_msg:
+                        print(f"   API Error: {error_msg}")
+                except Exception:
+                    pass
                 print("   Falling back to local-only tracing")
             else:
                 print(f"⚠️  [Sentience] Cloud init failed: HTTP {response.status_code}")
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error") or error_data.get("message", "Unknown error")
+                    print(f"   Error: {error_msg}")
+                    if "tier" in error_msg.lower() or "subscription" in error_msg.lower():
+                        print(f"   💡 This may be a tier/subscription issue")
+                except Exception:
+                    print(f"   Response: {response.text[:200]}")
                 print("   Falling back to local-only tracing")
 
         except requests.exceptions.Timeout: