notte-agent 1.4.0__py3-none-any.whl

notte_agent/README.md

@@ -0,0 +1,58 @@
+# How to build an LLM agent with *Notte*
+
+This guide explains how to build a custom LLM agent using *Notte*. The example in `agent.py` demonstrates a basic implementation that you can customize for your specific needs.
+
+## Overview
+
+*Notte* provides a flexible environment for web automation that can be controlled through an API. To build an agent with *Notte*, you need:
+
+1. An agent implementation that coordinates between your LLM and the *Notte* environment
+2. A parser that formats *Notte*'s outputs into prompts suitable for your LLM
+3. A way to interpret the LLM's responses back into *Notte* commands
+
+## Key Components
+
+### Agent
+
+The `Agent` class in `agent.py` shows how to:
+- Initialize a connection to your LLM service
+- Manage the conversation flow between the LLM and *Notte*
+- Track the state of task completion
+
+### Parser
+
+The parser is crucial for translating between *Notte* and your LLM. You'll need to:
+
+1. Create a custom parser (by extending `BaseNotteParser` or implementing the `Parser` interface)
+2. Define how to format:
+   - Observations from web pages
+   - Available actions
+   - Data extraction results
+   - Task completion status
+
+The provided `BaseNotteParser` is a simple example that you should modify based on your needs. Consider:
+- The prompt format your LLM works best with
+- How to structure web observations for your specific tasks
+- What action format makes sense for your use case
+- How to handle task completion and data extraction
+
+## Example Implementation
+
+See `agent.py` for a basic implementation. Key points to customize:
+- The parser implementation
+- The prompt engineering in the conversation flow
+- How task completion is determined
+- Error handling and retry logic
+
+## Best Practices
+
+1. **Custom Parser**: Don't just use the `BaseNotteParser` as-is. Create your own parser that:
+   - Formats observations in a way that makes sense for your LLM
+   - Structures action possibilities clearly
+   - Handles task-specific data extraction
+
+2. **Prompt Engineering**: Carefully design your system prompt and conversation flow
+
+3. **Error Handling**: Add robust error handling for both LLM and *Notte* interactions
+
+4. **Testing**: Test your parser and agent with different scenarios

notte_agent/__init__.py

@@ -0,0 +1,7 @@
+from notte_core import check_notte_version
+
+from notte_agent.main import Agent
+
+__version__ = check_notte_version("notte_agent")
+
+__all__ = ["Agent"]

notte_agent/common/base.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from notte_agent.common.types import AgentResponse
+
+
+class BaseAgent(ABC):
+    @abstractmethod
+    async def run(self, task: str, url: str | None = None) -> AgentResponse:
+        pass

notte_agent/common/config.py

@@ -0,0 +1,213 @@
+from abc import ABC, abstractmethod
+from argparse import ArgumentParser, Namespace
+from collections.abc import Callable
+from enum import StrEnum
+from typing import Any, ClassVar, Self, get_origin, get_type_hints
+
+from notte_browser.env import NotteEnvConfig
+from notte_core.common.config import FrozenConfig
+from notte_core.llms.engine import LlmModel
+from notte_sdk.types import DEFAULT_MAX_NB_STEPS
+from pydantic import Field, model_validator
+
+
+class RaiseCondition(StrEnum):
+    """How to raise an error when the agent fails to complete a step.
+
+    Either immediately upon failure, after retry, or never.
+    """
+
+    IMMEDIATELY = "immediately"
+    RETRY = "retry"
+    NEVER = "never"
+
+
+class DefaultAgentArgs(StrEnum):
+    ENV_DISABLE_WEB_SECURITY = "disable_web_security"
+    ENV_HEADLESS = "headless"
+    ENV_PERCEPTION_MODEL = "perception_model"
+    ENV_MAX_STEPS = "max_steps"
+
+    def with_prefix(self: Self, prefix: str = "env") -> str:
+        return f"{prefix}.{self.value}"
+
+
+class AgentConfig(FrozenConfig, ABC):
+    # make env private to avoid exposing the NotteEnvConfig class
+    env: NotteEnvConfig = Field(init=False)
+    reasoning_model: str = Field(
+        default=LlmModel.default(), description="The model to use for reasoning (i.e taking actions)."
+    )
+    include_screenshot: bool = Field(default=False, description="Whether to include a screenshot in the response.")
+    max_history_tokens: int | None = Field(
+        default=None,
+        description="The maximum number of tokens in the history. When the history exceeds this limit, the oldest messages are discarded.",
+    )
+    max_error_length: int = Field(
+        default=500, description="The maximum length of an error message to be forwarded to the reasoning model."
+    )
+    raise_condition: RaiseCondition = Field(
+        default=RaiseCondition.RETRY, description="How to raise an error when the agent fails to complete a step."
+    )
+    max_consecutive_failures: int = Field(
+        default=3, description="The maximum number of consecutive failures before the agent gives up."
+    )
+    force_env: bool | None = Field(
+        default=None,
+        description="Whether to allow the user to set the environment.",
+    )
+
+    @classmethod
+    @abstractmethod
+    def default_env(cls) -> NotteEnvConfig:
+        raise NotImplementedError("Subclasses must implement this method")
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_env(cls, values: dict[str, Any]) -> dict[str, Any]:
+        if "env" in values:
+            if "force_env" in values and values["force_env"]:
+                del values["force_env"]
+                return values
+            raise ValueError("Env should not be set by the user. Set `default_env` instead.")
+        values["env"] = cls.default_env()  # Set the env field using the subclass's method
+        return values
+
+    def groq(self: Self, deep: bool = True) -> Self:
+        return self.model(LlmModel.groq, deep=deep)
+
+    def openai(self: Self, deep: bool = True) -> Self:
+        return self.model(LlmModel.openai, deep=deep)
+
+    def gemini(self: Self, deep: bool = True) -> Self:
+        return self.model(LlmModel.gemini, deep=deep)
+
+    def cerebras(self: Self, deep: bool = True) -> Self:
+        return self.model(LlmModel.cerebras, deep=deep)
+
+    def model(self: Self, model: LlmModel, deep: bool = True) -> Self:
+        config = self._copy_and_validate(reasoning_model=model, max_history_tokens=LlmModel.context_length(model))
+        if deep:
+            config = config.map_env(lambda env: env.model(model))
+        return config
+
+    def use_vision(self: Self, value: bool = True) -> Self:
+        return self._copy_and_validate(include_screenshot=value)
+
+    def dev_mode(self: Self) -> Self:
+        return self._copy_and_validate(
+            raise_condition=RaiseCondition.IMMEDIATELY,
+            max_error_length=1000,
+            env=self.env.dev_mode(),
+            force_env=True,
+        )
+
+    def set_raise_condition(self: Self, value: RaiseCondition) -> Self:
+        return self._copy_and_validate(raise_condition=value)
+
+    def map_env(self: Self, env: Callable[[NotteEnvConfig], NotteEnvConfig]) -> Self:
+        return self._copy_and_validate(env=env(self.env), force_env=True)
+
+    @staticmethod
+    def _get_arg_type(python_type: Any) -> Any:
+        """Maps Python types to argparse types."""
+        type_map = {
+            str: str,
+            int: int,
+            float: float,
+            bool: bool,
+        }
+        return type_map.get(python_type, str)
+
+    @staticmethod
+    def create_base_parser() -> ArgumentParser:
+        """Creates a base ArgumentParser with all the fields from the config."""
+        parser = ArgumentParser()
+        _ = parser.add_argument(
+            f"--{DefaultAgentArgs.ENV_HEADLESS.with_prefix()}",
+            action="store_true",
+            help="Whether to run the browser in headless mode.",
+        )
+        _ = parser.add_argument(
+            f"--{DefaultAgentArgs.ENV_DISABLE_WEB_SECURITY.with_prefix()}",
+            action="store_true",
+            help="Whether disable web security.",
+        )
+        _ = parser.add_argument(
+            f"--{DefaultAgentArgs.ENV_PERCEPTION_MODEL.with_prefix()}",
+            type=str,
+            default=None,
+            help="The model to use for perception.",
+        )
+        _ = parser.add_argument(
+            f"--{DefaultAgentArgs.ENV_MAX_STEPS.with_prefix()}",
+            type=int,
+            default=DEFAULT_MAX_NB_STEPS,
+            help="The maximum number of steps the agent can take.",
+        )
+        return parser
+
+    @classmethod
+    def create_parser(cls) -> ArgumentParser:
+        """Creates an ArgumentParser with all the fields from the config."""
+        parser = cls.create_base_parser()
+        hints = get_type_hints(cls)
+
+        for field_name, field_info in cls.model_fields.items():
+            if field_name == "env":
+                continue
+            field_type = hints.get(field_name)
+            if get_origin(field_type) is ClassVar:
+                continue
+
+            default = field_info.default
+            help_text = field_info.description or "no description available"
+            arg_type = cls._get_arg_type(field_type)
+
+            _ = parser.add_argument(
+                f"--{field_name.replace('_', '-')}",
+                type=arg_type,
+                default=default,
+                help=f"{help_text} (default: {default})",
+            )
+
+        return parser
+
+    @classmethod
+    def from_args(cls: type[Self], args: Namespace) -> Self:
+        """Creates an AgentConfig from a Namespace of arguments.
+
+        The return type will match the class that called this method.
+        """
+        disallowed_args = ["task", "env.window.headless"]
+
+        env_args = {
+            k.replace("env.", "").replace("-", "_"): v
+            for k, v in vars(args).items()
+            if k.startswith("env.") and k not in disallowed_args
+        }
+        agent_args = {
+            k.replace("-", "_"): v
+            for k, v in vars(args).items()
+            if not k.startswith("env.") and k not in disallowed_args
+        }
+
+        def update_env(env: NotteEnvConfig) -> NotteEnvConfig:
+            operations: list[Callable[[NotteEnvConfig], NotteEnvConfig]] = []
+            if DefaultAgentArgs.ENV_HEADLESS in env_args:
+                headless = env_args[DefaultAgentArgs.ENV_HEADLESS]
+                operations.append(lambda env: env.headless(headless))
+                del env_args[DefaultAgentArgs.ENV_HEADLESS]
+            if DefaultAgentArgs.ENV_DISABLE_WEB_SECURITY in env_args:
+                disable_web_security = env_args[DefaultAgentArgs.ENV_DISABLE_WEB_SECURITY]
+                operations.append(
+                    lambda env: env.disable_web_security() if disable_web_security else env.enable_web_security()
+                )
+                del env_args[DefaultAgentArgs.ENV_DISABLE_WEB_SECURITY]
+
+            env = env._copy_and_validate(**env_args)
+            for operation in operations:
+                env = operation(env)
+            return env
+
+        return cls(**agent_args).map_env(update_env)

notte_agent/common/conversation.py

@@ -0,0 +1,246 @@
+import base64
+import json
+from dataclasses import dataclass, field
+from typing import TypeVar
+
+from litellm import (
+    AllMessageValues,
+    ChatCompletionAssistantMessage,
+    ChatCompletionAssistantToolCall,
+    ChatCompletionImageObject,
+    ChatCompletionSystemMessage,
+    ChatCompletionTextObject,
+    ChatCompletionToolMessage,
+    ChatCompletionUserMessage,
+    ModelResponse,  # type: ignore[reportPrivateImportUsage]
+    OpenAIMessageContent,
+)
+from litellm.utils import token_counter  # type: ignore[reportUnknownVariableType]
+from loguru import logger
+from notte_core.errors.llm import LLMParsingError
+from notte_core.llms.engine import LlmModel, StructuredContent
+from pydantic import BaseModel
+
+# Define valid message roles
+
+
+@dataclass
+class CachedMessage:
+    """Message with cached token count"""
+
+    message: AllMessageValues
+    token_count: int
+
+
+T = TypeVar("T", bound=BaseModel)
+
+
+@dataclass
+class Conversation:
+    """Manages conversation history and message extraction"""
+
+    history: list[CachedMessage] = field(default_factory=list)
+    json_extractor: StructuredContent = field(default_factory=lambda: StructuredContent(inner_tag="json"))
+    autosize: bool = False
+    model: str = LlmModel.default()
+    max_tokens: int | None = None
+    conservative_factor: float = 0.8
+
+    _total_tokens: int = field(default=0, init=False)
+    convert_tools_to_assistant: bool = False
+
+    def __post_init__(self) -> None:
+        if self.max_tokens is None:
+            self.max_tokens = LlmModel.context_length(self.model)
+
+    @property
+    def default_max_tokens(self) -> int:
+        if self.max_tokens is None:
+            raise ValueError("max_tokens is not set")
+        return self.max_tokens
+
+    @property
+    def conservative_max_tokens(self) -> int:
+        """Since token count isn't 100% accurate, allow to be
+        slightly conservative, to make sure we trim under the total context length"""
+        return int(self.default_max_tokens * self.conservative_factor)
+
+    def count_tokens(self, content: AllMessageValues) -> int:
+        """Count the number of tokens in a list of messages"""
+        return token_counter(model=self.model, messages=[content])
+
+    def total_tokens(self) -> int:
+        """Get total tokens in conversation history"""
+        return self._total_tokens
+
+    def trim_history_to_fit(self, new_content: AllMessageValues) -> None:
+        """Trim history to make room for new content while preserving system messages"""
+        if not self.autosize:
+            return
+
+        # Always keep system messages
+        init_messages: list[CachedMessage] = []
+        other_messages: list[CachedMessage] = []
+        is_init_msg = True
+        for msg in self.history:
+            match is_init_msg, msg.message["role"]:
+                case True, "system":
+                    init_messages.append(msg)
+                case True, "user":
+                    # keep first user message as init message (need task description)
+                    is_init_msg = False
+                    init_messages.append(msg)
+                case _, _:
+                    other_messages.append(msg)
+
+        new_content_tokens = self.count_tokens(new_content)
+        init_tokens = sum(msg.token_count for msg in init_messages)
+        available_tokens = self.conservative_max_tokens - init_tokens - new_content_tokens
+
+        # Remove oldest non-system messages until we have room
+        current_tokens = sum(msg.token_count for msg in other_messages)
+        has_trimmed = 0
+        while other_messages and current_tokens > available_tokens:
+            removed = other_messages.pop(0)
+            current_tokens -= removed.token_count
+            has_trimmed += 1
+
+        if has_trimmed > 0:
+            logger.info(
+                f"Trimmed {has_trimmed} message(s) to stay under max token limit (i.e {self.default_max_tokens // 1000}k)"
+            )
+
+        self.history = init_messages + other_messages
+        self._total_tokens = sum(msg.token_count for msg in self.history)
+
+    def _add_message(self, msg: AllMessageValues) -> None:
+        """Internal helper to add a message with token counting"""
+        token_count = self.count_tokens(msg)
+        if self.autosize:
+            self.trim_history_to_fit(msg)
+        cached_msg = CachedMessage(message=msg, token_count=token_count)
+        self.history.append(cached_msg)
+        self._total_tokens += token_count
+
+    def add_system_message(self, content: str) -> None:
+        """Add a system message to the conversation"""
+        self._add_message(ChatCompletionSystemMessage(role="system", content=content))
+
+    def format_image_content(self, image: bytes) -> ChatCompletionImageObject:
+        image_str = base64.b64encode(image).decode("utf-8")
+        return ChatCompletionImageObject(
+            type="image_url",
+            image_url={"url": f"data:image/png;base64,{image_str}"},
+        )
+
+    def format_user_contents(self, contents: list[str | bytes]) -> OpenAIMessageContent:
+        return [
+            (
+                ChatCompletionTextObject(type="text", text=content)
+                if isinstance(content, str)
+                else self.format_image_content(content)
+            )
+            for content in contents
+        ]
+
+    def add_user_message(self, content: OpenAIMessageContent, image: bytes | None = None) -> None:
+        """Add a user message to the conversation"""
+        _content: OpenAIMessageContent = content
+        if image is not None and isinstance(content, str):
+            _content = self.format_user_contents([content, image])
+        self._add_message(ChatCompletionUserMessage(role="user", content=_content))
+
+    def add_user_messages(self, contents: list[str | bytes]) -> None:
+        """Add a user message to the conversation"""
+        _content: OpenAIMessageContent = self.format_user_contents(contents)
+        self._add_message(ChatCompletionUserMessage(role="user", content=_content))
+
+    def add_assistant_message(self, content: str) -> None:
+        """Add an assistant message to the conversation"""
+        self._add_message(ChatCompletionAssistantMessage(role="assistant", content=content))
+
+    def add_tool_message(self, parsed_content: BaseModel, tool_id: str) -> None:
+        """Add a tool message to the conversation"""
+        content: str = str(parsed_content.model_dump(mode="json", exclude_unset=True))
+        if not self.convert_tools_to_assistant:
+            self._add_message(
+                ChatCompletionToolMessage(
+                    role="tool",
+                    content=content,
+                    tool_call_id=tool_id,
+                )
+            )
+        else:
+            # Optional, convert tools to assistant role
+            self._add_message(
+                ChatCompletionAssistantMessage(
+                    role="assistant",
+                    content="",
+                    tool_calls=[
+                        ChatCompletionAssistantToolCall(
+                            id=tool_id,
+                            type="function",
+                            function={
+                                "arguments": content,
+                                "name": parsed_content.__class__.__name__,
+                            },
+                        )
+                    ],
+                )
+            )
+
+    def parse_structured_response(self, response: ModelResponse | str, model: type[T]) -> T:
+        """Parse a structured response from the LLM into a Pydantic model
+
+        Args:
+            response: The LLM model response
+            model: The Pydantic model class to parse into
+
+        Returns:
+            Instance of the specified Pydantic model
+
+        Raises:
+            LLMParsingError: If response cannot be parsed into the model
+        """
+        if isinstance(response, str):
+            return model.model_validate(response)
+        if not response.choices:
+            raise LLMParsingError("No choices in LLM response")
+
+        choice = response.choices[0]
+        # Extract content from either streaming or non-streaming response
+        content: str | None = None
+        if isinstance(choice, dict):
+            message = choice.get("message", {})  # type: ignore[reportUnknownMemberType]
+            if isinstance(message, dict):
+                content = message.get("content")  # type: ignore[reportUnknownMemberType]
+        else:
+            content = getattr(choice, "text")
+
+        if not content:
+            raise LLMParsingError("No content in LLM response message")
+
+        try:
+            if content is None or not isinstance(content, str):
+                raise LLMParsingError("No content in LLM response message")
+            extracted = self.json_extractor.extract(content)
+            return model.model_validate_json(extracted)
+        except (json.JSONDecodeError, ValueError) as e:
+            raise LLMParsingError(f"Failed to parse response into {model.__name__}: {str(e)}")
+
+    def messages(self) -> list[AllMessageValues]:
+        """Get messages in LiteLLM format
+
+        Returns:
+            List of messages formatted for LiteLLM
+
+        Note:
+            This converts our internal message format to litellm's format.
+            litellm only supports 'assistant' role, so we map all roles to that.
+        """
+        return [msg.message for msg in self.history]
+
+    def reset(self) -> None:
+        """Clear all messages from the conversation"""
+        self.history.clear()
+        self._total_tokens = 0

notte_agent/common/notifier.py

@@ -0,0 +1,54 @@
+from abc import ABC, abstractmethod
+
+from typing_extensions import override
+
+from notte_agent.common.base import BaseAgent
+from notte_agent.common.types import AgentResponse
+
+
+class BaseNotifier(ABC):
+    """Base class for notification implementations."""
+
+    @abstractmethod
+    async def send_message(self, text: str) -> None:
+        """Send a message using the specific notification service."""
+        pass
+
+    async def notify(self, task: str, result: AgentResponse) -> None:
+        """Send a notification about the task result.
+
+        Args:
+            task: The task description
+            result: The agent's response to be sent
+        """
+        message = f"""
+Notte Agent Report 🌙
+
+Task Details:
+-------------
+Task: {task}
+Execution Time: {round(result.duration_in_s, 2)} seconds
+Status: {"✅ Success" if result.success else "❌ Failed"}
+
+
+Agent Response:
+--------------
+{result.answer}
+
+Powered by Notte 🌒"""
+        await self.send_message(text=message)
+
+
+class NotifierAgent(BaseAgent):
+    """Agent wrapper that sends notifications after task completion."""
+
+    def __init__(self, agent: BaseAgent, notifier: BaseNotifier):
+        self.agent: BaseAgent = agent
+        self.notifier: BaseNotifier = notifier
+
+    @override
+    async def run(self, task: str, url: str | None = None) -> AgentResponse:
+        """Run the agent and send notification about the result."""
+        result = await self.agent.run(task, url)
+        await self.notifier.notify(task, result)
+        return result

notte_agent/common/parser.py

@@ -0,0 +1,78 @@
+import json
+import re
+from abc import ABC, abstractmethod
+from typing import Literal
+
+from notte_core.actions.base import ExecutableAction
+from notte_core.controller.actions import (
+    BaseAction,
+    CompletionAction,
+    GotoAction,
+    ScrapeAction,
+)
+from pydantic import BaseModel
+
+
+class NotteStepAgentOutput(BaseModel):
+    observe: GotoAction | None = None
+    step: ExecutableAction | None = None
+    scrape: ScrapeAction | None = None
+    completion: CompletionAction | None = None
+
+    @property
+    def endpoint(self) -> Literal["observe", "step", "scrape", "done"] | None:
+        if self.observe is not None:
+            return "observe"
+        elif self.step is not None:
+            return "step"
+        elif self.scrape is not None:
+            return "scrape"
+        elif self.completion is not None:
+            return "done"
+        else:
+            return None
+
+    @property
+    def action(self) -> BaseAction | None:
+        if self.observe is not None:
+            return self.observe
+        elif self.step is not None:
+            return self.step
+        elif self.scrape is not None:
+            return self.scrape
+        else:
+            return None
+
+
+class ParameterizedAction(BaseModel):
+    action_id: str
+    params: dict[str, str] | None = None
+
+
+class BaseParser(ABC):
+    @abstractmethod
+    def parse(self, text: str) -> NotteStepAgentOutput | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def example_format(self, endpoint: Literal["observe", "step", "scrape"]) -> str | None:
+        raise NotImplementedError
+
+    @staticmethod
+    def search_pattern(text: str, tag: str) -> str | None:
+        pattern = re.compile(rf"<{tag}>(.*?)</{tag}>", re.IGNORECASE | re.DOTALL)
+        match = pattern.search(text)
+        return match.group(1).strip() if match else None
+
+    @staticmethod
+    def parse_json(text: str, tag: str | None = None) -> dict[str, str]:
+        if tag is not None:
+            _text = BaseParser.search_pattern(text, tag)
+            if _text is None:
+                raise ValueError(f"No text found within <{tag}> tags")
+            text = _text
+        try:
+            data: dict[str, str] = json.loads(text)
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON in action")
+        return data

notte_agent/common/perception.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+from notte_core.browser.observation import Observation
+
+
+class BasePerception(ABC):
+    @abstractmethod
+    def perceive_metadata(self, obs: Observation) -> str:
+        pass
+
+    @abstractmethod
+    def perceive_actions(self, obs: Observation) -> str:
+        pass
+
+    @abstractmethod
+    def perceive_data(self, obs: Observation) -> str:
+        pass
+
+    @abstractmethod
+    def perceive(self, obs: Observation) -> str:
+        pass