Errors

from nova_act import NovaAct, ActError, ActTimeoutError

try:
    with NovaAct(starting_page="https://example.com") as nova:
        nova.act("Complete task", timeout=30)
except ActTimeoutError:
    print("Task timed out")
except ActError as e:
    print(f"Act failed: {e.message}")
    print(f"Steps executed: {e.metadata.num_steps_executed}")

from nova_act import NovaActError

try:
    # NovaAct operations
    pass
except NovaActError as e:
    print(f"Nova Act error: {e}")

from nova_act import ActError

try:
    with NovaAct(starting_page="https://example.com") as nova:
        nova.act("Complete task")
except ActError as e:
    print(f"Error: {e.message}")
    if e.metadata:
        print(f"Session: {e.metadata.session_id}")
        print(f"Act ID: {e.metadata.act_id}")
        print(f"Steps: {e.metadata.num_steps_executed}")

from nova_act import ActExecutionError

try:
    nova.act("Complete task")
except ActExecutionError as e:
    print(f"Execution error: {e}")

from nova_act import ActCanceledError

try:
    nova.act("Long running task")
except ActCanceledError:
    print("User canceled the operation")

from nova_act import ActActuationError

try:
    nova.act("Click invalid element")
except ActActuationError as e:
    print(f"Actuation failed: {e.message}")

from nova_act import ActTimeoutError

try:
    nova.act("Complex task", timeout=10)
except ActTimeoutError:
    print("Task exceeded timeout")

from nova_act import ActStateGuardrailError, GuardrailDecision

def my_guardrail(state):
    if "blocked.com" in state.browser_url:
        return GuardrailDecision.BLOCK
    return GuardrailDecision.PASS

try:
    with NovaAct(starting_page="https://example.com", 
                 state_guardrail=my_guardrail) as nova:
        nova.act("Navigate")
except ActStateGuardrailError:
    print("Blocked by guardrail")

from nova_act import ActAgentError

try:
    nova.act("Impossible task")
except ActAgentError as e:
    print(f"Agent error: {e.message}")

from nova_act import ActAgentFailed

try:
    nova.act("Find element that doesn't exist")
except ActAgentFailed:
    print("Agent explicitly failed")

from nova_act import ActExceededMaxStepsError

try:
    nova.act("Complex task", max_steps=5)
except ActExceededMaxStepsError:
    print("Task required too many steps")

from nova_act import ActInvalidModelGenerationError

try:
    result = nova.act_get("Get data", schema={"type": "object"})
except ActInvalidModelGenerationError as e:
    print(f"Invalid model output: {e.message}")
    if e.raw_response:
        print(f"Raw response: {e.raw_response}")

from nova_act import ActInvalidToolError

try:
    nova.act("Use unknown tool")
except ActInvalidToolError:
    print("Model called non-existent tool")

from nova_act import ActInvalidToolSchemaError

try:
    nova.act("Call tool with wrong arguments")
except ActInvalidToolSchemaError:
    print("Tool arguments didn't match schema")

from nova_act import ActToolError

try:
    nova.act("Use failing tool")
except ActToolError:
    print("Tool execution failed")

from nova_act import ActMCPError

try:
    nova.act("Use MCP tool")
except ActMCPError:
    print("MCP tool failed")

from nova_act import ActAPIError

try:
    nova.act("Task")
except ActAPIError as e:
    print(f"API error: {e.message}")
    print(f"Status code: {e.status_code}")
    print(f"Request ID: {e.request_id}")

from nova_act import ActClientError

try:
    nova.act("Invalid request")
except ActClientError as e:
    print(f"Client error: {e.message}")
    print(f"Fix your request and try again")

from nova_act import ActBadRequestError

try:
    nova.act("Malformed request")
except ActBadRequestError:
    print("Request was malformed")

from nova_act import ActGuardrailsError

try:
    nova.act("Unsafe action")
except ActGuardrailsError:
    print("Request blocked by server guardrails")

from nova_act import ActRateLimitExceededError

try:
    nova.act("Task")
except ActRateLimitExceededError:
    print("Rate limit exceeded, try again later")

from nova_act import ActRequestThrottledError
import time

try:
    nova.act("Task")
except ActRequestThrottledError:
    print("Throttled, waiting before retry...")
    time.sleep(5)

from nova_act import ActDailyQuotaExceededError

try:
    nova.act("Task")
except ActDailyQuotaExceededError:
    print("Daily quota exceeded")

from nova_act import ActServerError

try:
    nova.act("Task")
except ActServerError as e:
    print(f"Server error: {e.message}")
    print("Please report to customer support")

from nova_act import ActBadResponseError

try:
    nova.act("Task")
except ActBadResponseError:
    print("Received malformed response from server")

from nova_act import ActServiceUnavailableError
import time

try:
    nova.act("Task")
except ActServiceUnavailableError:
    print("Service unavailable, retrying...")
    time.sleep(10)

from nova_act import ActInternalServerError

try:
    nova.act("Task")
except ActInternalServerError:
    print("Internal server error")

from nova_act import NoHumanInputToolAvailable

try:
    # NovaAct without human_input_callbacks
    nova.act("Task requiring human input")
except NoHumanInputToolAvailable:
    print("Need to provide human_input_callbacks")

from nova_act import ApproveCanceledError

try:
    nova.act("Task with approval")
except ApproveCanceledError:
    print("User denied approval")

from nova_act import UiTakeoverCanceledError

try:
    nova.act("Task with UI takeover")
except UiTakeoverCanceledError:
    print("User canceled during UI takeover")

from nova_act import NovaAct, StartFailed

try:
    nova = NovaAct(starting_page="invalid://url")
    nova.start()
except StartFailed as e:
    print(f"Failed to start: {e}")

from nova_act import NovaAct, StopFailed

try:
    nova.stop()
except StopFailed as e:
    print(f"Failed to stop: {e}")

from nova_act import NovaAct, ValidationFailed

try:
    nova = NovaAct(
        starting_page="https://example.com",
        screen_width=-100  # Invalid
    )
except ValidationFailed as e:
    print(f"Validation error: {e}")

from nova_act import NovaAct, ClientNotStarted

try:
    nova = NovaAct(starting_page="https://example.com")
    nova.act("Task")  # Error: not started
except ClientNotStarted:
    print("Must call start() first")
    nova.start()

from nova_act import Workflow, AuthError

try:
    workflow = Workflow(
        model_id="nova-act-latest",
        boto_session_kwargs={},
        nova_act_api_key="key"  # Can't use both
    )
except AuthError as e:
    print(f"Auth error: {e}")

from nova_act import (
    NovaAct,
    ActTimeoutError,
    ActRateLimitExceededError,
    ActAgentFailed,
    ActError
)

with NovaAct(starting_page="https://example.com") as nova:
    try:
        nova.act("Complete task", timeout=30)
    except ActTimeoutError:
        print("Task timed out, consider increasing timeout")
    except ActRateLimitExceededError:
        print("Rate limited, wait before retrying")
    except ActAgentFailed:
        print("Agent couldn't complete task, try different prompt")
    except ActError as e:
        print(f"Other act error: {e}")

from nova_act import NovaAct, ActError

with NovaAct(starting_page="https://example.com") as nova:
    try:
        nova.act("Task")
    except ActError as e:
        if e.metadata:
            print(f"Failed after {e.metadata.num_steps_executed} steps")
            print(f"Session: {e.metadata.session_id}")
            print(f"Prompt: {e.metadata.prompt}")

from nova_act import NovaAct, ActRequestThrottledError, ActServerError
import time

def act_with_retry(nova, prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            return nova.act(prompt)
        except ActRequestThrottledError:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Throttled, waiting {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise
        except ActServerError:
            if attempt < max_retries - 1:
                print(f"Server error, retrying...")
                time.sleep(5)
            else:
                raise

with NovaAct(starting_page="https://example.com") as nova:
    result = act_with_retry(nova, "Complete task")