Agent Runtime

from browser_use import BrowserSession, BrowserProfile
from sentience import get_extension_dir
from sentience.backends import BrowserUseAdapter
from sentience.agent_runtime import AgentRuntime
from sentience.tracing import Tracer, JsonlTraceSink

# 1. Setup browser-use with Sentience extension
profile = BrowserProfile(args=[f"--load-extension={get_extension_dir()}"])
session = BrowserSession(browser_profile=profile)
await session.start()

# 2. Create backend from browser-use session
adapter = BrowserUseAdapter(session)
backend = await adapter.create_backend()

# 3. Navigate using browser-use
page = await session.get_current_page()
await page.goto("https://example.com")

# 4. Create AgentRuntime with backend
sink = JsonlTraceSink("trace.jsonl")
tracer = Tracer(run_id="test-run", sink=sink)
runtime = AgentRuntime(backend=backend, tracer=tracer)

# 5. Use runtime for verification loop
await runtime.snapshot()
runtime.assert_(url_matches(r"example\.com"), label="on_homepage")
runtime.assert_(exists("role=button"), label="has_buttons")

# 6. Check task completion
if runtime.assert_done(exists("text~'Success'"), label="task_complete"):
    print("Task completed!")

# Same setup as above, but with API key for smart element ranking
runtime = AgentRuntime(
    backend=backend,
    tracer=tracer,
    sentience_api_key="sk_pro_xxxxx",  # Enables Gateway refinement
)

# Snapshots now use server-side ML ranking/filtering
await runtime.snapshot()  # Elements are refined by Gateway

from sentience.agent_runtime import AgentRuntime

# New: Using backend parameter (recommended)
runtime = AgentRuntime(
    backend=backend,              # Any BrowserBackend implementation
    tracer=tracer,                # Tracer for event emission
    sentience_api_key="sk_...",   # Optional: Pro/Enterprise Gateway refinement
)

from sentience import AsyncSentienceBrowser
from sentience.agent_runtime import AgentRuntime

async with AsyncSentienceBrowser() as browser:
    page = await browser.new_page()
    await page.goto("https://example.com")

    # Use factory method for backward compatibility
    runtime = await AgentRuntime.from_sentience_browser(
        browser=browser,
        page=page,
        tracer=tracer,
    )
    await runtime.snapshot()

# Take snapshot (required before element assertions)
snap = runtime.snapshot()
print(f"Found {len(snap.elements)} elements")

# Begin a new step
step_id = runtime.begin_step("Navigate to checkout")
print(f"Step ID: {step_id}")

# Or with explicit step index
step_id = runtime.begin_step("Verify cart", step_index=2)

# URL assertion
url_ok = runtime.assert_(url_contains("checkout"), "on_checkout_page")

# Element assertion
has_btn = runtime.assert_(exists("role=button text~'Pay'"), "has_pay_button")

# Required assertion (gates step success)
ready = runtime.assert_(
    all_of(url_contains("checkout"), exists("role=button")),
    "checkout_ready",
    required=True
)

# Check if task goal is achieved
if runtime.assert_done(exists("text~'Order Confirmed'"), "order_placed"):
    print("Order successfully placed!")
    # runtime.is_task_done is now True

from sentience import url_matches, url_contains

# Regex match on URL
runtime.assert_(url_matches(r"https://.*\.example\.com"), "is_https")

# Substring match on URL
runtime.assert_(url_contains("checkout"), "on_checkout")

from sentience import exists, not_exists, element_count

# Element exists (using query syntax)
runtime.assert_(exists("role=button text~'Submit'"), "has_submit")

# Element does not exist
runtime.assert_(not_exists("text~'Error'"), "no_errors")

# Element count check
runtime.assert_(element_count("role=listitem", min=5), "has_items")

from sentience import all_of, any_of

# All conditions must pass
runtime.assert_(
    all_of(
        url_contains("checkout"),
        exists("role=button text~'Pay'"),
        not_exists("text~'Error'")
    ),
    "checkout_ready"
)

# Any condition must pass
runtime.assert_(
    any_of(
        exists("text~'Success'"),
        exists("text~'Complete'")
    ),
    "task_done"
)

from sentience import custom
from sentience.verification import AssertContext, AssertOutcome

def my_predicate(ctx: AssertContext) -> AssertOutcome:
    # Custom logic using ctx.snapshot and ctx.url
    has_items = len(ctx.snapshot.elements) > 10
    return AssertOutcome(
        passed=has_items,
        reason="Found sufficient elements" if has_items else "Too few elements",
        details={"element_count": len(ctx.snapshot.elements)}
    )

runtime.assert_(custom(my_predicate), "custom_check")

# Check if all assertions in current step passed
if runtime.all_assertions_passed():
    print("All assertions passed!")

# Check if all required assertions passed
if runtime.required_assertions_passed():
    print("All required assertions passed!")

# Check if task is done
if runtime.is_task_done:
    print("Task complete!")

# Get assertions data for step_end event
assertions_data = runtime.get_assertions_for_step_end()
print(f"Assertions: {assertions_data['assertions']}")
print(f"Task done: {assertions_data.get('task_done', False)}")
print(f"Task label: {assertions_data.get('task_done_label')}")

# Flush and clear assertions for next step
assertions = runtime.flush_assertions()

# Reset task_done state for next task
runtime.reset_task_done()

from sentience import (
    AgentRuntime,
    SentienceBrowser,
    all_of,
    exists,
    not_exists,
    url_contains,
    url_matches,
)
from sentience.tracer_factory import create_tracer

def main():
    # Setup
    tracer = create_tracer(api_key="sk_...", run_id="verification-demo", upload_trace=False)
    browser = SentienceBrowser(api_key="sk_...", headless=False)
    browser.start()

    try:
        runtime = AgentRuntime(browser, browser.page, tracer)

        # Navigate
        browser.page.goto("https://example.com")
        browser.page.wait_for_load_state("networkidle")

        # Step 1: Verify page loaded
        runtime.begin_step("Verify page loaded correctly")
        runtime.snapshot()

        # Run assertions
        runtime.assert_(url_contains("example.com"), "on_example_domain")
        runtime.assert_(url_matches(r"https://.*example\.com"), "url_is_https")
        runtime.assert_(exists("role=heading"), "has_heading")
        runtime.assert_(not_exists("text~'Error'"), "no_error_message")

        # Combined assertion
        runtime.assert_(
            all_of(url_contains("example"), exists("role=link")),
            "page_fully_ready",
        )

        # Check task completion
        if runtime.assert_done(exists("text~'Example Domain'"), "reached_example_page"):
            print("Task completed!")

        # Summary
        print(f"All passed: {runtime.all_assertions_passed()}")
        print(f"Task complete: {runtime.is_task_done}")

    finally:
        tracer.close(blocking=True)
        browser.close()

if __name__ == "__main__":
    main()