notte-integrations 0.0.dev0__tar.gz

notte_integrations-0.0.dev0/.gitignore

@@ -0,0 +1,179 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+ignore.*
+llm_usage.jsonl
+llm_parsing_error.jsonl
+traces/
+
+**/__pycache__/**
+.DS_Store
+**/.DS_Store
+old
+notebook

notte_integrations-0.0.dev0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: notte-integrations
+Version: 0.0.dev0
+Summary: The integrations for Notte
+Author-email: Notte Team  <hello@notte.cc>
+Requires-Python: >=3.11
+Requires-Dist: browser-use>=0.1.40
+Requires-Dist: browserbase>=1.2.0
+Requires-Dist: discord-py<2.5.0,>=2.3.0
+Requires-Dist: fastapi>=0.115.8
+Requires-Dist: hvac>=2.3.0
+Requires-Dist: langchain-google-genai>=2.1.1
+Requires-Dist: notte-agent==0.0.dev
+Requires-Dist: notte-browser==0.0.dev
+Requires-Dist: notte-core==0.0.dev
+Requires-Dist: slack-sdk>=3.34.0
+Requires-Dist: uvicorn>=0.29.0

notte_integrations-0.0.dev0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "notte-integrations"
+version = "0.0.dev"
+description = "The integrations for Notte"
+readme = "README.md"
+authors = [
+    { name = "Notte Team ", email = "hello@notte.cc" }
+]
+packages = [
+    { include = "notte_integrations", from = "src" },
+]
+
+
+requires-python = ">=3.11"
+dependencies = [
+    "notte_core==0.0.dev",
+    "notte_browser==0.0.dev",
+    "notte_agent==0.0.dev",
+    "discord-py>=2.3.0,<2.5.0",
+    "fastapi>=0.115.8",
+    "uvicorn>=0.29.0",
+    "hvac>=2.3.0",
+    "browserbase>=1.2.0",
+    "browser-use>=0.1.40",
+    "langchain-google-genai>=2.1.1",
+    "slack-sdk>=3.34.0",
+]
+
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

notte_integrations-0.0.dev0/src/notte_integrations/__init__.py

@@ -0,0 +1,3 @@
+from notte_core import check_notte_version
+
+__version__ = check_notte_version("notte_integrations")

notte_integrations-0.0.dev0/src/notte_integrations/api/fastapi.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, HTTPException
+from notte_agent.common.base import BaseAgent
+from notte_agent.common.types import AgentResponse
+from notte_sdk.types import AgentRunRequest
+
+
+def create_agent_router(agent: BaseAgent, prefix: str = "agent") -> APIRouter:
+    """
+    Creates a FastAPI router that serves the given agent.
+
+    Args:
+        agent: The BaseAgent implementation to serve
+        prefix: Optional URL prefix for the API endpoints
+
+    Returns:
+        APIRouter instance with agent endpoints
+    """
+    router = APIRouter(
+        prefix=prefix,
+        tags=[agent.__class__.__name__],
+    )
+
+    @router.post("/run", response_model=AgentResponse)
+    async def run_agent(request: Annotated[AgentRunRequest, "Agent request parameters"]) -> AgentResponse:  # pyright: ignore[reportUnusedFunction]
+        try:
+            return await agent.run(task=request.task, url=request.url)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    return router

notte_integrations-0.0.dev0/src/notte_integrations/credentials/README.md

@@ -0,0 +1,37 @@
+## Basic example code
+
+```python
+from notte_agent.main import Agent
+from notte_integrations.credentials.hashicorp.vault import HashiCorpVault
+import os
+from dotenv import load_dotenv
+
+
+# CRITICAL: make sure to start the vault server before running the agent
+# > cd packages/notte-integrations/src/notte_integrations/credentials/hashicorp
+# > docker-compose --env-file ../../../../../.env up
+
+# Then, set the VAULT_URL environment variable either to .env file or
+
+# VAULT_URL=http://0.0.0.0:8200
+# VAULT_DEV_ROOT_TOKEN_ID=<your-vault-dev-root-token-id>
+
+# Load environment variables
+load_dotenv()
+
+# Initialize vault with environment variables
+vault = HashiCorpVault(
+    url=os.getenv("VAULT_URL"),
+    token=os.getenv("VAULT_DEV_ROOT_TOKEN_ID")
+)
+
+# Add credentials from environment variables
+vault.add_credentials(
+    url="https://x.com",
+    username=os.getenv("TWITTER_USERNAME"),
+    password=os.getenv("TWITTER_PASSWORD")
+)
+
+# Configure and initialize agent with vault
+agent = Agent(vault=vault)
+```

notte_integrations-0.0.dev0/src/notte_integrations/credentials/hashicorp/docker-compose.yml

@@ -0,0 +1,15 @@
+version: '3.8'
+services:
+  vault:
+    image: hashicorp/vault:latest
+    container_name: vault
+    ports:
+      - "8200:8200"
+    environment:
+      - VAULT_DEV_ROOT_TOKEN_ID=${VAULT_DEV_ROOT_TOKEN_ID}
+      - VAULT_DEV_LISTEN_ADDRESS=0.0.0.0:8200
+    cap_add:
+      - IPC_LOCK
+    command: server -dev
+
+# run it using docker-compose --env-file /path/to/.env up

notte_integrations-0.0.dev0/src/notte_integrations/credentials/hashicorp/vault.py

@@ -0,0 +1,174 @@
+import os
+from dataclasses import dataclass
+from typing import Any, Protocol, final
+
+from hvac.exceptions import InvalidPath
+from notte_core.credentials.base import (
+    BaseVault,
+    CredentialField,
+    VaultCredentials,
+)
+from notte_core.utils.url import get_root_domain
+from typing_extensions import override
+
+
+class SysProtocol(Protocol):
+    def list_mounted_secrets_engines(self) -> Any: ...
+    def enable_secrets_engine(self, backend_type: str, path: str, options: dict[str, Any]) -> Any: ...
+
+
+class SecretsProtocol(Protocol):
+    def read_secret_version(self, path: str, mount_point: str) -> Any: ...
+    def create_or_update_secret(self, path: str, secret: dict[str, Any], mount_point: str) -> Any: ...
+    def delete_metadata_and_all_versions(self, path: str, mount_point: str) -> Any: ...
+
+
+@dataclass
+class HashiCorpVaultClientProtocol:
+    url: str
+    token: str
+    sys: SysProtocol
+
+
+try:
+    from hvac import Client as HashiCorpVaultClient
+
+    VAULT_AVAILABLE = True
+except ImportError:
+    VAULT_AVAILABLE = False  # type: ignore
+
+
+def check_vault_imports():
+    if not VAULT_AVAILABLE:
+        raise ImportError(
+            (
+                "The 'hvac' package is required for HashiCorp Vault integration."
+                " Install 'vault' optional dependencies with 'uv sync --extra vault'"
+            )
+        )
+
+
+@final
+class HashiCorpVault(BaseVault):
+    """HashiCorp Vault implementation of the BaseVault interface."""
+
+    def __init__(self, url: str, token: str):
+        check_vault_imports()
+        self.client: HashiCorpVaultClientProtocol = HashiCorpVaultClient(url=url, token=token)  # type: ignore
+        self.secrets: SecretsProtocol = self.client.secrets.kv.v2  # type: ignore
+        self._mount_path: str = "secret"
+        self._init_vault()
+
+    def _init_vault(self) -> None:
+        try:
+            mounts = self.client.sys.list_mounted_secrets_engines()
+            if self._mount_path not in mounts["data"]:
+                self.client.sys.enable_secrets_engine(
+                    backend_type="kv", path=self._mount_path, options={"version": "2"}
+                )
+            else:
+                mount_info = mounts["data"][f"{self._mount_path}/"]["options"]
+                if mount_info.get("version") != "2":
+                    raise ValueError(f"Existing {self._mount_path} mount is not a KV v2 secrets engine")
+        except Exception as e:
+            if "path is already in use" not in str(e):
+                raise e
+
+    @override
+    def _set_singleton_credentials(self, creds: list[CredentialField]) -> None:
+        for cred in creds:
+            if not cred.singleton:
+                raise ValueError(f"{cred.__class__} can't be set as singleton credential: url-specific only")
+
+        self.secrets.create_or_update_secret(
+            path="singleton_credentials",
+            secret=dict(
+                **{cred.__class__.__qualname__: cred.value for cred in creds},
+            ),
+            mount_point=self._mount_path,
+        )
+
+    @override
+    def get_singleton_credentials(self) -> list[CredentialField]:
+        try:
+            secret = self.secrets.read_secret_version(path="singleton_credentials", mount_point=self._mount_path)
+        except InvalidPath:
+            return []
+
+        data = secret["data"]["data"]
+
+        return [CredentialField.registry[key](value=value) for key, value in data.items()]
+
+    @override
+    def _add_credentials(self, creds: VaultCredentials) -> None:
+        for cred in creds.creds:
+            if cred.singleton:
+                raise ValueError(f"{cred.__class__} can't be set as url specific credential: singleton only")
+        domain = get_root_domain(creds.url)
+        self.secrets.create_or_update_secret(
+            path=f"credentials/{domain}",
+            secret=dict(
+                url=creds.url,
+                **{cred.__class__.__qualname__: cred.value for cred in creds.creds},
+            ),
+            mount_point=self._mount_path,
+        )
+
+    @override
+    def _get_credentials_impl(self, url: str) -> VaultCredentials | None:
+        domain = get_root_domain(url)
+        try:
+            secret = self.secrets.read_secret_version(path=f"credentials/{domain}", mount_point=self._mount_path)
+            data = secret["data"]["data"]
+            url = data["url"]
+            del data["url"]
+
+            return VaultCredentials(
+                url=url,
+                creds=[CredentialField.registry[key](value=value) for key, value in data.items()],
+            )
+
+        except Exception:
+            return None
+
+    @override
+    def remove_credentials(self, url: str) -> None:
+        domain = get_root_domain(url)
+        self.secrets.delete_metadata_and_all_versions(path=f"credentials/{domain}", mount_point=self._mount_path)
+
+    @classmethod
+    def create_from_env(cls) -> "HashiCorpVault":
+        """Create a HashiCorpVault instance from environment variables.
+
+        Requires VAULT_URL and VAULT_DEV_ROOT_TOKEN_ID to be set in environment variables.
+        Automatically loads from .env file if present.
+
+        Returns:
+            HashiCorpVault: Initialized vault instance
+
+        Raises:
+            ValueError: If required environment variables are missing or vault server is not running
+        """
+        vault_url = os.getenv("VAULT_URL")
+        vault_token = os.getenv("VAULT_DEV_ROOT_TOKEN_ID")
+
+        if not vault_url or not vault_token:
+            raise ValueError(
+                """"
+VAULT_URL and VAULT_DEV_ROOT_TOKEN_ID must be set in the .env file.
+For example if you are running the vault locally:
+VAULT_URL=http://0.0.0.0:8200
+VAULT_DEV_ROOT_TOKEN_ID=<your-vault-dev-root-token-id>
+"""
+            )
+
+        try:
+            return cls(url=vault_url, token=vault_token)
+        except ConnectionError as e:
+            vault_not_running_instructions = """
+Make sure to start the vault server before running the agent.
+Instructions to start the vault server:
+> cd packages/notte-integrations/src/notte_integrations/credentials/hashicorp
+> docker-compose --env-file ../../../../../.env up
+"""
+            raise ValueError(f"Vault server is not running. {vault_not_running_instructions}") from e

notte_integrations-0.0.dev0/src/notte_integrations/notifiers/README.md

@@ -0,0 +1,129 @@
+# Notte Notifiers
+
+This guide explains how to set up notification services for Notte using Discord and Slack integrations.
+
+## Table of Contents
+- [Overview](#overview)
+- [Slack Integration](#slack-integration)
+  - [Creating a Slack App](#creating-a-slack-app)
+  - [Getting the Required Credentials](#getting-the-slack-credentials)
+  - [Configuration](#slack-configuration)
+- [Discord Integration](#discord-integration)
+  - [Creating a Discord Bot](#creating-a-discord-bot)
+  - [Getting the Required Credentials](#getting-the-discord-credentials)
+  - [Configuration](#discord-configuration)
+- [Using the Notifiers](#using-the-notifiers)
+
+## Overview
+
+Notte provides notification services that can send task results to both Slack and Discord. Each integration requires specific credentials that you'll need to obtain from their respective platforms.
+
+## Slack Integration
+
+### Creating a Slack App
+
+1. Go to [Slack API](https://api.slack.com/apps)
+2. Click "Create New App"
+3. Select "From scratch"
+4. Enter a name for your app (e.g., "Notte Notifier")
+5. Select the workspace where you want to install the app
+6. Click "Create App"
+
+### Getting the Slack Credentials
+
+1. In your app's settings page, navigate to "OAuth & Permissions" in the sidebar
+2. Scroll down to "Scopes" and add the following Bot Token Scopes:
+   - `chat:write`
+   - `chat:write.public`
+3. Scroll back to the top and click "Install to Workspace"
+4. Authorize the app installation
+5. After installation, you'll see a "Bot User OAuth Token" that starts with `xoxb-` - copy this token
+
+To get your channel ID:
+1. Open Slack in your browser
+2. Navigate to the channel where you want to send notifications
+3. The channel ID is in the URL: `https://app.slack.com/client/TXXXXXXXX/CXXXXXXXXX`
+   (The `CXXXXXXXXX` part is your channel ID)
+
+### Slack Configuration
+
+Use the following code to initialize the Slack notifier:
+
+```python
+from notte_core.notifiers.slack import SlackConfig, SlackNotifier
+
+slack_config = SlackConfig(
+    token="xoxb-your-token-here",
+    channel_id="C0123456789"
+)
+
+slack_notifier = SlackNotifier(slack_config)
+```
+
+## Discord Integration
+
+### Creating a Discord Bot
+
+1. Go to the [Discord Developer Portal](https://discord.com/developers/applications)
+2. Click "New Application"
+3. Enter a name for your app (e.g., "Notte Notifier")
+4. Navigate to the "Bot" tab in the left sidebar
+5. Click "Add Bot"
+6. Under the "Privileged Gateway Intents" section, enable "Message Content Intent"
+
+### Getting the Discord Credentials
+
+To get your bot token:
+1. In the "Bot" tab, click "Reset Token" to generate a new token
+2. Copy the token - this is your bot token
+
+To invite the bot to your server:
+1. Go to the "OAuth2" tab and then "URL Generator"
+2. Select the following scopes:
+   - `bot`
+3. Select the following bot permissions:
+   - "Send Messages"
+   - "Read Message History"
+4. Copy the generated URL and open it in your browser
+5. Select the server you want to add the bot to and authorize
+
+To get your channel ID:
+1. In Discord, enable Developer Mode (User Settings > Advanced > Developer Mode)
+2. Right-click on the channel you want to send messages to
+3. Select "Copy ID"
+
+### Discord Configuration
+
+Use the following code to initialize the Discord notifier:
+
+```python
+from notte_core.notifiers.discord import DiscordConfig, DiscordNotifier
+
+discord_config = DiscordConfig(
+    token="your-discord-bot-token-here",
+    channel_id=123456789012345678  # This should be an integer, not a string
+)
+
+discord_notifier = DiscordNotifier(discord_config)
+```
+
+## Using the Notifiers
+
+Once configured, you can use the notifiers to send notifications:
+
+```python
+from notte_core.common.agent.types import AgentResponse
+
+# Create a sample response
+response = AgentResponse(answer="This is a test notification")
+
+# Send notifications
+await slack_notifier.notify("Test Task", response)
+await discord_notifier.notify("Test Task", response)
+```
+
+The notifications will be formatted according to each platform's markdown styles:
+- Slack uses `*text*` for bold
+- Discord uses `**text**` for bold
+
+Remember that both notifiers require async functions, so they must be called within an async context.

notte_integrations-0.0.dev0/src/notte_integrations/notifiers/discord.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+import discord
+from notte_agent.common.notifier import BaseNotifier
+from pydantic import BaseModel
+from typing_extensions import override
+
+
+class DiscordConfig(BaseModel):
+    """Configuration for Discord sending functionality."""
+
+    token: str
+    channel_id: int
+
+
+class DiscordNotifier(BaseNotifier):
+    """Discord notification implementation."""
+
+    def __init__(self, config: DiscordConfig) -> None:
+        super().__init__()
+        self.config: DiscordConfig = config
+        self._client: discord.Client = discord.Client(intents=discord.Intents.default())
+
+    @override
+    async def send_message(self, text: str) -> None:
+        """Send a message to the configured Discord channel."""
+        try:
+
+            @self._client.event
+            async def on_ready():  # pyright: ignore[reportUnusedFunction]
+                try:
+                    channel = self._client.get_channel(self.config.channel_id)
+                    if channel is None:
+                        raise ValueError(f"Could not find channel with ID: {self.config.channel_id}")
+                    _: Any = await channel.send(text)  # pyright: ignore[reportUnknownMemberType,reportAttributeAccessIssue]
+                finally:
+                    await self._client.close()
+
+            await self._client.start(self.config.token)
+        except Exception as e:
+            raise ValueError(f"Failed to send Discord message: {str(e)}")

notte_integrations-0.0.dev0/src/notte_integrations/notifiers/mail.py

@@ -0,0 +1,67 @@
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+from notte_agent.common.notifier import BaseNotifier
+from pydantic import BaseModel
+from typing_extensions import override
+
+
+class EmailConfig(BaseModel):
+    """Configuration for email sending functionality."""
+
+    smtp_server: str
+    smtp_port: int = 587
+    sender_email: str
+    sender_password: str
+    receiver_email: str
+    subject: str = "Notte Agent Task Report"
+
+
+class EmailNotifier(BaseNotifier):
+    """Email notification implementation."""
+
+    def __init__(self, config: EmailConfig) -> None:
+        super().__init__()  # Call parent class constructor
+        self.config: EmailConfig = config
+        self._server: smtplib.SMTP | None = None
+
+    async def connect(self) -> None:
+        """Connect to the SMTP server."""
+        if self._server is not None:
+            return
+
+        self._server = smtplib.SMTP(host=self.config.smtp_server, port=self.config.smtp_port)
+        _ = self._server.starttls()
+        _ = self._server.login(user=self.config.sender_email, password=self.config.sender_password)
+
+    async def disconnect(self) -> None:
+        """Disconnect from the SMTP server."""
+        if self._server is not None:
+            _ = self._server.quit()
+            self._server = None
+
+    @override
+    async def send_message(self, text: str) -> None:
+        """Send an email with the given subject and body."""
+        await self.connect()
+        try:
+            if self._server is None:
+                await self.connect()
+
+            msg = MIMEMultipart()
+            msg["From"] = self.config.sender_email
+            msg["To"] = self.config.receiver_email
+            msg["Subject"] = self.config.subject
+
+            msg.attach(MIMEText(text, "plain"))
+
+            if self._server:
+                _ = self._server.send_message(msg)
+        finally:
+            await self.disconnect()
+
+    def __del__(self):
+        """Ensure SMTP connection is closed on deletion."""
+        if self._server is not None:
+            _ = self._server.quit()

notte_integrations-0.0.dev0/src/notte_integrations/notifiers/slack.py

@@ -0,0 +1,25 @@
+from notte_agent.common.notifier import BaseNotifier
+from pydantic import BaseModel
+from slack_sdk.web.client import WebClient
+from typing_extensions import override
+
+
+class SlackConfig(BaseModel):
+    """Configuration for Slack sending functionality."""
+
+    token: str
+    channel_id: str
+
+
+class SlackNotifier(BaseNotifier):
+    """Slack notification implementation."""
+
+    def __init__(self, config: SlackConfig) -> None:
+        super().__init__()
+        self.config: SlackConfig = config
+        self._client: WebClient = WebClient(token=self.config.token)
+
+    @override
+    async def send_message(self, text: str) -> None:
+        """Send a message to the configured Slack channel."""
+        _ = self._client.chat_postMessage(channel=self.config.channel_id, text=text)  # type: ignore[type_unknown]

notte_integrations-0.0.dev0/src/notte_integrations/sessions/anchor.py

@@ -0,0 +1,57 @@
+import os
+from typing import Any
+
+import requests
+from loguru import logger
+from pydantic import Field
+from typing_extensions import override
+
+from notte_integrations.sessions.cdp_session import CDPSession, CDPSessionsManager
+
+
+def get_anchor_api_key() -> str:
+    anchor_api_key: str | None = os.getenv("ANCHOR_API_KEY")
+    if anchor_api_key is None:
+        raise ValueError("ANCHOR_API_KEY is not set")
+    return anchor_api_key
+
+
+class AnchorSessionsManager(CDPSessionsManager):
+    anchor_base_url: str = "https://api.anchorbrowser.io"
+    use_proxy: bool = True
+    solve_captcha: bool = True
+    anchor_api_key: str = Field(default_factory=get_anchor_api_key)
+
+    @override
+    def create_session_cdp(self) -> CDPSession:
+        if self.verbose:
+            logger.info("Creating Anchor session...")
+
+        browser_configuration: dict[str, Any] = {}
+
+        if self.use_proxy:
+            browser_configuration["proxy_config"] = {"type": "anchor-residential", "active": True}
+
+        if self.solve_captcha:
+            browser_configuration["captcha_config"] = {"active": True}
+
+        response = requests.post(
+            f"{self.anchor_base_url}/api/sessions",
+            headers={
+                "anchor-api-key": self.anchor_api_key,
+                "Content-Type": "application/json",
+            },
+            json=browser_configuration,
+        )
+        response.raise_for_status()
+        session_id: str = response.json()["id"]
+        return CDPSession(
+            session_id=session_id,
+            cdp_url=f"wss://connect.anchorbrowser.io?apiKey={self.anchor_api_key}&sessionId={session_id}",
+        )
+
+    @override
+    def close_session_cdp(self, session_id: str) -> bool:
+        if self.verbose:
+            logger.info(f"Closing CDP session for URL {session_id}")
+        return True

notte_integrations-0.0.dev0/src/notte_integrations/sessions/browserbase.py

@@ -0,0 +1,82 @@
+import os
+
+from loguru import logger
+from typing_extensions import override
+
+from notte_integrations.sessions.cdp_session import CDPSession, CDPSessionsManager
+
+try:
+    from browserbase import Browserbase
+except ImportError:
+    raise ImportError("Install with notte[browserbase] to include browserbase integration")
+
+
+# TODO: use api with requests instead of sdk so we don't have the added dependency
+class BrowserBaseSessionsManager(CDPSessionsManager):
+    def __init__(
+        self,
+        verbose: bool = False,
+        stealth: bool = True,
+    ):
+        super().__init__()
+
+        bb_api_key: str | None = os.getenv("BROWSERBASE_API_KEY")
+        bb_project_id: str | None = os.getenv("BROWSERBASE_PROJECT_ID")
+
+        if bb_api_key is None:
+            raise ValueError("BROWSERBASE_API_KEY env variable is not set")
+
+        if bb_project_id is None:
+            raise ValueError("BROWSERBASE_PROJECT_ID env variable is not set")
+
+        self.bb_api_key: str = bb_api_key
+        self.bb_project_id: str = bb_project_id
+
+        self.bb: Browserbase = Browserbase(api_key=self.bb_api_key)
+        self.stealth: bool = stealth
+        self.verbose: bool = verbose
+
+    @override
+    def create_session_cdp(self) -> CDPSession:
+        if self.verbose:
+            logger.info("Creating BrowserBase session...")
+
+        stealth_args = dict(
+            browser_settings={
+                "fingerprint": {
+                    "browsers": ["chrome", "firefox", "edge", "safari"],
+                    "devices": ["mobile", "desktop"],
+                    "locales": ["en-US", "en-GB"],
+                    "operatingSystems": ["android", "ios", "linux", "macos", "windows"],
+                    "screen": {
+                        "maxHeight": 1080,
+                        "maxWidth": 1920,
+                        "minHeight": 1080,
+                        "minWidth": 1920,
+                    },
+                    "viewport": {
+                        "width": 1920,
+                        "height": 1080,
+                    },
+                },
+                "solveCaptchas": True,
+            },
+            proxies=True,
+        )
+
+        args = stealth_args if self.stealth else {}
+        session = self.bb.sessions.create(project_id=self.bb_project_id, **args)  # type: ignore
+
+        if self.verbose:
+            logger.info(f"Got BrowserBase session {session}")
+
+        return CDPSession(
+            session_id=session.id,
+            cdp_url=session.connect_url,
+        )
+
+    @override
+    def close_session_cdp(self, session_id: str) -> bool:
+        if self.verbose:
+            logger.info(f"Closing CDP session for URL {session_id}")
+        return True

notte_integrations-0.0.dev0/src/notte_integrations/sessions/cdp_session.py

@@ -0,0 +1,77 @@
+from abc import ABC, abstractmethod
+
+from loguru import logger
+from notte_browser.playwright import WindowManager
+from notte_browser.window import BrowserResource, BrowserWindowOptions
+from notte_sdk.types import BrowserType
+from patchright.async_api import Browser as PatchrightBrowser
+from pydantic import BaseModel, Field
+from typing_extensions import override
+
+
+class CDPSession(BaseModel):
+    session_id: str
+    cdp_url: str
+    resource: BrowserResource | None = None
+
+
+class CDPSessionsManager(WindowManager, ABC):
+    sessions: dict[str, CDPSession] = Field(default_factory=dict)
+    last_session: CDPSession | None = Field(default=None)
+    browser_type: BrowserType = Field(default=BrowserType.CHROMIUM)
+
+    @abstractmethod
+    def create_session_cdp(self) -> CDPSession:
+        pass
+
+    @abstractmethod
+    def close_session_cdp(self, session_id: str) -> bool:
+        pass
+
+    @override
+    async def create_playwright_browser(self, options: BrowserWindowOptions) -> PatchrightBrowser:
+        session = self.create_session_cdp()
+        if session.cdp_url in self.sessions:
+            raise ValueError(f"Session {session.session_id} already exists")
+
+        cdp_options = options.set_cdp_url(session.cdp_url)
+        logger.info(f"Connecting to CDP at {cdp_options.cdp_url}")
+        browser = await self.connect_cdp_browser(cdp_options)
+        self.sessions[session.cdp_url] = session
+        self.last_session = session
+        return browser
+
+    @override
+    async def get_browser_resource(self, options: BrowserWindowOptions) -> BrowserResource:
+        resource = await super().get_browser_resource(options)
+        cdp_url = resource.options.cdp_url
+        if cdp_url is None:
+            if self.last_session is None:
+                raise ValueError(f"CDP URL is not set for resource {cdp_url} and last session is not set")
+            logger.info(f"Setting CDP URL for resource {cdp_url} to {self.last_session.cdp_url}")
+            resource.options = resource.options.set_cdp_url(self.last_session.cdp_url)
+            cdp_url = self.last_session.cdp_url
+        if cdp_url not in self.sessions:
+            raise ValueError(f"Session {cdp_url} not found")
+        self.sessions[cdp_url].resource = resource
+        self.browser = None  # pyright: ignore[reportUnannotatedClassAttribute]
+        self.last_session = None
+        return resource
+
+    @override
+    async def release_browser_resource(self, resource: BrowserResource) -> None:
+        await super().release_browser_resource(resource)
+        cdp_url = resource.options.cdp_url
+        if cdp_url not in self.sessions:
+            raise ValueError(f"Session {cdp_url} not found")
+        session = self.sessions[cdp_url]
+        status = self.close_session_cdp(session.session_id)
+        if not status:
+            logger.error(f"Failed to close session {session.session_id}")
+        del self.sessions[cdp_url]
+
+    @override
+    async def stop(self) -> None:
+        await super().stop()
+        for session in self.sessions.values():
+            _ = self.close_session_cdp(session.session_id)

notte_integrations-0.0.dev0/src/notte_integrations/sessions/steel.py

@@ -0,0 +1,53 @@
+import os
+
+import requests
+from loguru import logger
+from pydantic import Field
+from typing_extensions import override
+
+from notte_integrations.sessions.cdp_session import CDPSession, CDPSessionsManager
+
+
+def get_steel_api_key() -> str:
+    steel_api_key: str | None = os.getenv("STEEL_API_KEY")
+    if steel_api_key is None:
+        raise ValueError("STEEL_API_KEY is not set")
+    return steel_api_key
+
+
+class SteelSessionsManager(CDPSessionsManager):
+    steel_base_url: str = "api.steel.dev"  # localhost:3000"
+    steel_api_key: str = Field(default_factory=get_steel_api_key)
+
+    @override
+    def create_session_cdp(self) -> CDPSession:
+        logger.info("Creating Steel session...")
+
+        url = f"https://{self.steel_base_url}/v1/sessions"
+
+        headers = {"Steel-Api-Key": self.steel_api_key}
+
+        response = requests.post(url, headers=headers)
+        response.raise_for_status()
+        data: dict[str, str] = response.json()
+        if "localhost" in self.steel_base_url:
+            cdp_url = f"ws://{self.steel_base_url}/v1/devtools/browser/{data['id']}"
+        else:
+            cdp_url = f"wss://connect.steel.dev?apiKey={self.steel_api_key}&sessionId={data['id']}"
+        return CDPSession(session_id=data["id"], cdp_url=cdp_url)
+
+    @override
+    def close_session_cdp(self, session_id: str) -> bool:
+        if self.verbose:
+            logger.info(f"Closing CDP session for URL {session_id}")
+
+        url = f"https://{self.steel_base_url}/v1/sessions/{session_id}/release"
+
+        headers = {"Steel-Api-Key": self.steel_api_key}
+
+        response = requests.post(url, headers=headers)
+        if response.status_code != 200:
+            if self.verbose:
+                logger.error(f"Failed to release Steel session {session_id}: {response.json()}")
+            return False
+        return True