Merge branch 'main' into deepinfra_models

Author: SentienceDEV

.github/workflows/test.yml

@@ -40,61 +40,8 @@ jobs:
         # Also clean .pyc files in sentience package specifically
         find sentience -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || python -c "import pathlib, shutil; [shutil.rmtree(p) for p in pathlib.Path('sentience').rglob('__pycache__') if p.is_dir()]" || true
         find sentience -name "*.pyc" -delete 2>/dev/null || python -c "import pathlib; [p.unlink() for p in pathlib.Path('sentience').rglob('*.pyc')]" || true
-        # CRITICAL: Fix assertTrue bug if it exists in source (shouldn't happen, but safety check)
-        python << 'PYEOF'
-        import re
-        import os
-        import sys
-
-        # Set UTF-8 encoding for Windows compatibility
-        if sys.platform == 'win32':
-            import io
-            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
-            sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
-
-        file_path = 'sentience/agent_runtime.py'
-        print(f'=== Auto-fix check for {file_path} ===')
-        try:
-            if not os.path.exists(file_path):
-                print(f'ERROR: {file_path} not found!')
-                sys.exit(1)
-
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-
-            if 'self.assertTrue(' in content:
-                print('WARNING: Found self.assertTrue( in source file! Auto-fixing...')
-                # Count occurrences
-                count = len(re.findall(r'self\.assertTrue\s*\(', content))
-                print(f'Found {count} occurrence(s) of self.assertTrue(')
-
-                # Replace all occurrences
-                new_content = re.sub(r'self\.assertTrue\s*\(', 'self.assert_(', content)
-
-                # Write back
-                with open(file_path, 'w', encoding='utf-8') as f:
-                    f.write(new_content)
-
-                # Verify the fix
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    verify_content = f.read()
-                    if 'self.assertTrue(' in verify_content:
-                        print('ERROR: Auto-fix failed! File still contains self.assertTrue(')
-                        sys.exit(1)
-                    else:
-                        print('OK: Auto-fixed: Replaced self.assertTrue( with self.assert_(')
-                        print('OK: Verified: File no longer contains self.assertTrue(')
-            else:
-                print('OK: Source file is correct (uses self.assert_())')
-        except Exception as e:
-            print(f'ERROR in auto-fix: {e}')
-            import traceback
-            traceback.print_exc()
-            sys.exit(1)
-        PYEOF
-        # Verify source file is fixed before installation
-        echo "=== Verifying source file after auto-fix ==="
-        python -c "import sys; import io; sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace') if sys.platform == 'win32' else sys.stdout; content = open('sentience/agent_runtime.py', 'r', encoding='utf-8').read(); assert 'self.assertTrue(' not in content, 'Source file still has self.assertTrue( after auto-fix!'; print('OK: Source file verified: uses self.assert_()')"
+        # Ensure source uses assert_ (no auto-rewrite).
+        python -c "import sys; import io; sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace') if sys.platform == 'win32' else sys.stdout; content = open('sentience/agent_runtime.py', 'r', encoding='utf-8').read(); assert 'self.assertTrue(' not in content, 'Source file still has self.assertTrue('; print('OK: Source file verified: uses self.assert_()')"
 
         # Force reinstall to ensure latest code
         pip install --no-cache-dir --force-reinstall -e ".[dev]"

.gitignore

@@ -60,3 +60,7 @@ Thumbs.db
 # Temporary directories from sync workflows
 extension-temp/
 playground/
+
+# Allow bundled extension assets under sentience/extension/dist
+!sentience/extension/dist/
+!sentience/extension/dist/**

scripts/sync_extension.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+CHROME_DIR="${REPO_ROOT}/sentience-chrome"
+SDK_EXT_DIR="${REPO_ROOT}/sdk-python/sentience/extension"
+
+if [[ ! -d "${CHROME_DIR}" ]]; then
+  echo "[sync_extension] sentience-chrome not found at ${CHROME_DIR}"
+  exit 1
+fi
+
+if [[ ! -f "${CHROME_DIR}/package.json" ]]; then
+  echo "[sync_extension] package.json missing in sentience-chrome"
+  exit 1
+fi
+
+echo "[sync_extension] Building sentience-chrome..."
+pushd "${CHROME_DIR}" >/dev/null
+npm run build
+popd >/dev/null
+
+echo "[sync_extension] Syncing dist/ and pkg/ to sdk-python..."
+mkdir -p "${SDK_EXT_DIR}/dist" "${SDK_EXT_DIR}/pkg"
+cp "${CHROME_DIR}/dist/"* "${SDK_EXT_DIR}/dist/"
+cp "${CHROME_DIR}/pkg/"* "${SDK_EXT_DIR}/pkg/"
+
+echo "[sync_extension] Done."

sentience/agent.py

@@ -143,6 +143,25 @@ def _compute_hash(self, text: str) -> str:
         """Compute SHA256 hash of text."""
         return hashlib.sha256(text.encode("utf-8")).hexdigest()
 
+    def _best_effort_post_snapshot_digest(self, goal: str) -> str | None:
+        """
+        Best-effort post-action snapshot digest for tracing.
+        """
+        try:
+            snap_opts = SnapshotOptions(
+                limit=min(10, self.default_snapshot_limit),
+                goal=f"{goal} (post)",
+            )
+            snap_opts.screenshot = False
+            snap_opts.show_overlay = self.config.show_overlay if self.config else None
+            post_snap = snapshot(self.browser, snap_opts)
+            if post_snap.status != "success":
+                return None
+            digest_input = f"{post_snap.url}{post_snap.timestamp}"
+            return f"sha256:{self._compute_hash(digest_input)}"
+        except Exception:
+            return None
+
     def _get_element_bbox(self, element_id: int | None, snap: Snapshot) -> dict[str, float] | None:
         """Get bounding box for an element from snapshot."""
         if element_id is None:
@@ -513,6 +532,10 @@ def act(  # noqa: C901
                     snapshot_event_data = TraceEventBuilder.build_snapshot_event(snap_with_diff)
                     pre_elements = snapshot_event_data.get("elements", [])
 
+                    post_snapshot_digest = (
+                        self._best_effort_post_snapshot_digest(goal) if self.tracer else None
+                    )
+
                     # Build complete step_end event
                     step_end_data = TraceEventBuilder.build_step_end_event(
                         step_id=step_id,
@@ -522,6 +545,7 @@ def act(  # noqa: C901
                         pre_url=pre_url,
                         post_url=post_url,
                         snapshot_digest=snapshot_digest,
+                        post_snapshot_digest=post_snapshot_digest,
                         llm_data=llm_data,
                         exec_data=exec_data,
                         verify_data=verify_data,
@@ -601,6 +625,7 @@ def act(  # noqa: C901
                             pre_url=_step_pre_url,
                             post_url=post_url,
                             snapshot_digest=snapshot_digest,
+                            post_snapshot_digest=None,
                             llm_data=llm_data,
                             exec_data=exec_data,
                             verify_data=None,
@@ -1155,6 +1180,10 @@ async def act(  # noqa: C901
                     snapshot_event_data = TraceEventBuilder.build_snapshot_event(snap_with_diff)
                     pre_elements = snapshot_event_data.get("elements", [])
 
+                    post_snapshot_digest = (
+                        self._best_effort_post_snapshot_digest(goal) if self.tracer else None
+                    )
+
                     # Build complete step_end event
                     step_end_data = TraceEventBuilder.build_step_end_event(
                         step_id=step_id,
@@ -1164,6 +1193,7 @@ async def act(  # noqa: C901
                         pre_url=pre_url,
                         post_url=post_url,
                         snapshot_digest=snapshot_digest,
+                        post_snapshot_digest=post_snapshot_digest,
                         llm_data=llm_data,
                         exec_data=exec_data,
                         verify_data=verify_data,
@@ -1243,6 +1273,7 @@ async def act(  # noqa: C901
                             pre_url=_step_pre_url,
                             post_url=post_url,
                             snapshot_digest=snapshot_digest,
+                            post_snapshot_digest=None,
                             llm_data=llm_data,
                             exec_data=exec_data,
                             verify_data=None,

sentience/agent_runtime.py

@@ -65,13 +65,15 @@
 
 import asyncio
 import difflib
+import hashlib
 import time
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from .captcha import CaptchaContext, CaptchaHandlingError, CaptchaOptions, CaptchaResolution
 from .failure_artifacts import FailureArtifactBuffer, FailureArtifactsOptions
 from .models import Snapshot, SnapshotOptions
+from .trace_event_builder import TraceEventBuilder
 from .verification import AssertContext, AssertOutcome, Predicate
 
 if TYPE_CHECKING:
@@ -138,6 +140,8 @@ def __init__(
 
         # Snapshot state
         self.last_snapshot: Snapshot | None = None
+        self._step_pre_snapshot: Snapshot | None = None
+        self._step_pre_url: str | None = None
 
         # Failure artifacts (Phase 1)
         self._artifact_buffer: FailureArtifactBuffer | None = None
@@ -148,6 +152,12 @@ def __init__(
 
         # Assertions accumulated during current step
         self._assertions_this_step: list[dict[str, Any]] = []
+        self._step_goal: str | None = None
+        self._last_action: str | None = None
+        self._last_action_error: str | None = None
+        self._last_action_outcome: str | None = None
+        self._last_action_duration_ms: int | None = None
+        self._last_action_success: bool | None = None
 
         # Task completion tracking
         self._task_done: bool = False
@@ -250,6 +260,11 @@ async def snapshot(self, **kwargs: Any) -> Snapshot:
         # Check if using legacy browser (backward compat)
         if hasattr(self, "_legacy_browser") and hasattr(self, "_legacy_page"):
             self.last_snapshot = await self._legacy_browser.snapshot(self._legacy_page, **kwargs)
+            if self.last_snapshot is not None:
+                self._cached_url = self.last_snapshot.url
+                if self._step_pre_snapshot is None:
+                    self._step_pre_snapshot = self.last_snapshot
+                    self._step_pre_url = self.last_snapshot.url
             return self.last_snapshot
 
         # Use backend-agnostic snapshot
@@ -262,6 +277,11 @@ async def snapshot(self, **kwargs: Any) -> Snapshot:
         options = SnapshotOptions(**options_dict)
 
         self.last_snapshot = await backend_snapshot(self.backend, options=options)
+        if self.last_snapshot is not None:
+            self._cached_url = self.last_snapshot.url
+            if self._step_pre_snapshot is None:
+                self._step_pre_snapshot = self.last_snapshot
+                self._step_pre_url = self.last_snapshot.url
         if not skip_captcha_handling:
             await self._handle_captcha_if_needed(self.last_snapshot, source="gateway")
         return self.last_snapshot
@@ -414,6 +434,7 @@ async def record_action(
         """
         Record an action in the artifact timeline and capture a frame if enabled.
         """
+        self._last_action = action
         if not self._artifact_buffer:
             return
         self._artifact_buffer.record_step(
@@ -425,6 +446,107 @@ async def record_action(
         if self._artifact_buffer.options.capture_on_action:
             await self._capture_artifact_frame()
 
+    def _compute_snapshot_digest(self, snap: Snapshot | None) -> str | None:
+        if snap is None:
+            return None
+        try:
+            return (
+                "sha256:"
+                + hashlib.sha256(f"{snap.url}{snap.timestamp}".encode("utf-8")).hexdigest()
+            )
+        except Exception:
+            return None
+
+    async def emit_step_end(
+        self,
+        *,
+        action: str | None = None,
+        success: bool | None = None,
+        error: str | None = None,
+        outcome: str | None = None,
+        duration_ms: int | None = None,
+        attempt: int = 0,
+        verify_passed: bool | None = None,
+        verify_signals: dict[str, Any] | None = None,
+        post_url: str | None = None,
+        post_snapshot_digest: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Emit a step_end event using TraceEventBuilder.
+        """
+        goal = self._step_goal or ""
+        pre_snap = self._step_pre_snapshot or self.last_snapshot
+        pre_url = (
+            self._step_pre_url
+            or (pre_snap.url if pre_snap else None)
+            or self._cached_url
+            or ""
+        )
+
+        if post_url is None:
+            try:
+                post_url = await self.get_url()
+            except Exception:
+                post_url = (
+                    (self.last_snapshot.url if self.last_snapshot else None) or self._cached_url
+                )
+        post_url = post_url or pre_url
+
+        pre_digest = self._compute_snapshot_digest(pre_snap)
+        post_digest = post_snapshot_digest or self._compute_snapshot_digest(self.last_snapshot)
+        url_changed = bool(pre_url and post_url and str(pre_url) != str(post_url))
+
+        assertions_data = self.get_assertions_for_step_end()
+        assertions = assertions_data.get("assertions") or []
+
+        signals = dict(verify_signals or {})
+        signals.setdefault("url_changed", url_changed)
+        if error and "error" not in signals:
+            signals["error"] = error
+
+        passed = (
+            bool(verify_passed)
+            if verify_passed is not None
+            else self.required_assertions_passed()
+        )
+
+        exec_success = bool(success) if success is not None else bool(
+            self._last_action_success if self._last_action_success is not None else passed
+        )
+
+        exec_data: dict[str, Any] = {
+            "success": exec_success,
+            "action": action or self._last_action or "unknown",
+            "outcome": outcome or self._last_action_outcome or "",
+        }
+        if duration_ms is not None:
+            exec_data["duration_ms"] = int(duration_ms)
+        if error:
+            exec_data["error"] = error
+
+        verify_data = {
+            "passed": bool(passed),
+            "signals": signals,
+        }
+
+        step_end_data = TraceEventBuilder.build_step_end_event(
+            step_id=self.step_id or "",
+            step_index=int(self.step_index),
+            goal=goal,
+            attempt=int(attempt),
+            pre_url=str(pre_url or ""),
+            post_url=str(post_url or ""),
+            snapshot_digest=pre_digest,
+            llm_data={},
+            exec_data=exec_data,
+            verify_data=verify_data,
+            pre_elements=None,
+            assertions=assertions,
+            post_snapshot_digest=post_digest,
+        )
+        self.tracer.emit("step_end", step_end_data, step_id=self.step_id)
+        return step_end_data
+
     async def _capture_artifact_frame(self) -> None:
         if not self._artifact_buffer:
             return
@@ -511,6 +633,14 @@ def begin_step(self, goal: str, step_index: int | None = None) -> str:
         """
         # Clear previous step state
         self._assertions_this_step = []
+        self._step_pre_snapshot = None
+        self._step_pre_url = None
+        self._step_goal = goal
+        self._last_action = None
+        self._last_action_error = None
+        self._last_action_outcome = None
+        self._last_action_duration_ms = None
+        self._last_action_success = None
 
         # Update step index
         if step_index is not None:

sentience/backends/playwright_backend.py

@@ -22,6 +22,7 @@
 """
 
 import asyncio
+import inspect
 import mimetypes
 import os
 import time
@@ -56,7 +57,14 @@ def __init__(self, page: "AsyncPage") -> None:
         # Best-effort download tracking (does not change behavior unless a download occurs).
         # pylint: disable=broad-exception-caught
         try:
-            self._page.on("download", lambda d: asyncio.create_task(self._track_download(d)))
+            result = self._page.on(
+                "download", lambda d: asyncio.create_task(self._track_download(d))
+            )
+            if inspect.isawaitable(result):
+                try:
+                    asyncio.get_running_loop().create_task(result)
+                except RuntimeError:
+                    pass
         except Exception:
             pass