render-lab-tasks-browserbase 0.1.0__tar.gz

render_lab_tasks_browserbase-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+*.egg-info/
+.env
+.env.*
+!.env.example

render_lab_tasks_browserbase-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Render Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

render_lab_tasks_browserbase-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.5
+Name: render-lab-tasks-browserbase
+Version: 0.1.0
+Summary: browserbase tasks for Render Workflows
+Project-URL: Repository, https://github.com/render-lab/render-tasks-python
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: httpx<0.29,>=0.28
+Requires-Dist: playwright<2,>=1.50
+Requires-Dist: render-lab-tasks-core<0.2,>=0.1.1
+Requires-Dist: render==1.0.1
+Description-Content-Type: text/markdown
+
+# render-lab-tasks-browserbase
+
+Twelve Browserbase tasks for contexts, sessions, browser actions and artifacts.
+Use `render_lab_tasks_browserbase.tasks` for the wrapped tasks and injectable raw
+implementations. The package root is inert; all boundaries use JSON DTOs.
+
+## Environment
+
+`BROWSERBASE_API_KEY` is required lazily on first use. `BROWSERBASE_PROJECT_ID` is
+an optional default project; create calls can supply `projectId` explicitly.
+
+## Behavior
+
+Session creation finds a matching idempotency key before creating a paid session.
+Browser actions reconnect through Playwright CDP and always close their local
+connection. No local browser installation is required. Closing a session is an
+explicit operation. Each HTTP operation makes one attempt; durable retries own retry timing.
+
+Screenshots, uploads, downloads and log output enforce byte budgets. Downloads
+read ZIP metadata without extracting files onto disk. The compressed archive has
+a 100 MiB transfer cap, and file content is read only up to its requested bound.
+Python applies the declared action timeout and keeps the total log text within its
+budget; these correct omissions in the pinned TS implementation. See ADR-0014.
+Live verification is pending credentials and a disposable Browserbase project.
+
+## Installation
+
+```sh
+pip install render-lab-tasks-browserbase==0.1.0
+```

render_lab_tasks_browserbase-0.1.0/README.md

@@ -0,0 +1,30 @@
+# render-lab-tasks-browserbase
+
+Twelve Browserbase tasks for contexts, sessions, browser actions and artifacts.
+Use `render_lab_tasks_browserbase.tasks` for the wrapped tasks and injectable raw
+implementations. The package root is inert; all boundaries use JSON DTOs.
+
+## Environment
+
+`BROWSERBASE_API_KEY` is required lazily on first use. `BROWSERBASE_PROJECT_ID` is
+an optional default project; create calls can supply `projectId` explicitly.
+
+## Behavior
+
+Session creation finds a matching idempotency key before creating a paid session.
+Browser actions reconnect through Playwright CDP and always close their local
+connection. No local browser installation is required. Closing a session is an
+explicit operation. Each HTTP operation makes one attempt; durable retries own retry timing.
+
+Screenshots, uploads, downloads and log output enforce byte budgets. Downloads
+read ZIP metadata without extracting files onto disk. The compressed archive has
+a 100 MiB transfer cap, and file content is read only up to its requested bound.
+Python applies the declared action timeout and keeps the total log text within its
+budget; these correct omissions in the pinned TS implementation. See ADR-0014.
+Live verification is pending credentials and a disposable Browserbase project.
+
+## Installation
+
+```sh
+pip install render-lab-tasks-browserbase==0.1.0
+```

render_lab_tasks_browserbase-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "render-lab-tasks-browserbase"
+version = "0.1.0"
+description = "browserbase tasks for Render Workflows"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = ["playwright>=1.50,<2","render==1.0.1", "httpx>=0.28,<0.29", "render-lab-tasks-core>=0.1.1,<0.2"]
+
+[project.urls]
+Repository = "https://github.com/render-lab/render-tasks-python"
+
+[tool.uv.sources]
+render-lab-tasks-core = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/render_lab_tasks_browserbase"]

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/__init__.py

@@ -0,0 +1 @@
+"""Import .tasks explicitly to register durable tasks."""

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/_app.py

@@ -0,0 +1,3 @@
+from render import Workflows
+
+app = Workflows()

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/capture_screenshot.py

@@ -0,0 +1,20 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_NO_RETRY
+from .types import CaptureScreenshotInput, CaptureScreenshotResult
+
+
+async def capture_screenshot_impl(
+    ctx: TaskContext, input: CaptureScreenshotInput, *, deps: Deps | None = None
+) -> CaptureScreenshotResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.capture_screenshot(input)
+
+
+@app.task(name="browserbase.captureScreenshot", retry=BROWSERBASE_NO_RETRY)
+async def capture_screenshot(
+    ctx: TaskContext, input: CaptureScreenshotInput
+) -> CaptureScreenshotResult:
+    return await capture_screenshot_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/client.py

@@ -0,0 +1,509 @@
+"""Injected vendor interface and one-attempt async HTTP adapter."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import io
+import json
+import os
+import zipfile
+from collections.abc import AsyncIterator, Mapping
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Any, Protocol
+
+import httpx
+from render_lab_tasks_core.bounded import (
+    MAX_BINARY_BYTES,
+    MAX_TEXT_BYTES,
+    BoundedText,
+    bounded_binary,
+    bounded_text,
+    validate_byte_limit,
+)
+from render_lab_tasks_core.http import ApiError, HttpClient, enc, pick, query
+
+from . import types as t
+
+IDEMPOTENCY_METADATA_KEY = "_render_tasks_idempotency_key"
+
+
+def integer(value: float, minimum: int, maximum: float = float("inf")) -> bool:
+    return not isinstance(value, bool) and minimum <= value <= maximum and int(value) == value
+
+
+def iso(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, (int, float)):
+        return (
+            datetime.fromtimestamp(value / 1000, UTC)
+            .isoformat(timespec="milliseconds")
+            .replace("+00:00", "Z")
+        )
+    return str(value)
+
+
+def session(raw: Any) -> t.SessionDTO:
+    return {
+        "sessionId": raw["id"],
+        "projectId": raw["projectId"],
+        "status": raw["status"],
+        "contextId": raw.get("contextId"),
+        "region": raw["region"],
+        "keepAlive": raw["keepAlive"],
+        "createdAt": iso(raw.get("createdAt")),
+        "updatedAt": iso(raw.get("updatedAt")),
+        "startedAt": iso(raw.get("startedAt")),
+        "expiresAt": iso(raw.get("expiresAt")),
+    }
+
+
+def download(session_id: str, info: zipfile.ZipInfo) -> t.DownloadDTO:
+    value = json.dumps(
+        {"sessionId": session_id, "name": info.filename}, ensure_ascii=False, separators=(",", ":")
+    ).encode()
+    extensions = {
+        "txt": "text/plain",
+        "csv": "text/csv",
+        "json": "application/json",
+        "html": "text/html",
+        "pdf": "application/pdf",
+        "png": "image/png",
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "gif": "image/gif",
+        "zip": "application/zip",
+    }
+    return {
+        "downloadId": base64.urlsafe_b64encode(value).decode().rstrip("="),
+        "sessionId": session_id,
+        "filename": info.filename,
+        "contentType": extensions.get(
+            info.filename.rsplit(".", 1)[-1].lower(), "application/octet-stream"
+        ),
+        "byteCount": info.file_size,
+        "checksum": f"{info.CRC:08x}",
+        "createdAt": "",
+    }
+
+
+def all_match(item: Any, input: Any, keys: tuple[str, ...]) -> bool:
+    return all(key not in input or item[key] == input[key] for key in keys)
+
+
+def serialize(value: Any, fallback: str) -> str:
+    return (
+        json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+        if value is not None
+        else fallback
+    )
+
+
+class Port(Protocol):
+    async def capture_screenshot(
+        self, input: t.CaptureScreenshotInput
+    ) -> t.CaptureScreenshotResult: ...
+    async def close_session(self, input: t.SessionIdInput) -> t.CloseSessionResult: ...
+    async def create_context(self, input: t.CreateContextInput) -> t.CreateContextResult: ...
+    async def create_session(self, input: t.CreateSessionInput) -> t.CreateSessionResult: ...
+    async def delete_context(self, input: t.DeleteContextInput) -> t.DeleteContextResult: ...
+    async def get_download(self, input: t.GetDownloadInput) -> t.GetDownloadResult: ...
+    async def get_session(self, input: t.SessionIdInput) -> t.SessionDTO: ...
+    async def get_session_logs(self, input: t.GetSessionLogsInput) -> t.GetSessionLogsResult: ...
+    async def get_session_replay(
+        self, input: t.GetSessionReplayInput
+    ) -> t.GetSessionReplayResult: ...
+    async def list_downloads(self, input: t.ListDownloadsInput) -> t.ListDownloadsResult: ...
+    async def run_actions(self, input: t.RunActionsInput) -> t.RunActionsResult: ...
+    async def upload_files(self, input: t.UploadFilesInput) -> t.UploadFilesResult: ...
+
+
+@dataclass(frozen=True)
+class Deps:
+    browserbase: Port
+
+
+class Client:
+    def __init__(self, http: httpx.AsyncClient, env: Mapping[str, str] | None = None) -> None:
+        self.env = os.environ if env is None else env
+        self.http = http
+        self.api = HttpClient(
+            http, "https://api.browserbase.com/v1", auth=self._auth, label="Browserbase API"
+        )
+
+    def _auth(self) -> dict[str, str]:
+        key = self.env.get("BROWSERBASE_API_KEY")
+        if not key:
+            raise ValueError("BROWSERBASE_API_KEY is required for the browserbase.* tasks.")
+        return {"x-bb-api-key": key, "Accept": "application/json"}
+
+    async def create_context(self, input: t.CreateContextInput) -> t.CreateContextResult:
+        project = input.get("projectId", self.env.get("BROWSERBASE_PROJECT_ID"))
+        raw = await self.api.call(
+            "/contexts", method="POST", body={"projectId": project} if project else {}
+        )
+        return {"contextId": raw["id"]}
+
+    async def delete_context(self, input: t.DeleteContextInput) -> t.DeleteContextResult:
+        deleted = True
+        try:
+            await self.api.call(
+                "/contexts/" + enc(input["contextId"]), method="DELETE", headers={"Accept": "*/*"}
+            )
+        except ApiError as error:
+            if error.status != 404:
+                raise
+            deleted = False
+        return {"contextId": input["contextId"], "deleted": deleted}
+
+    async def create_session(self, input: t.CreateSessionInput) -> t.CreateSessionResult:
+        key = input.get("idempotencyKey", "").strip()
+        if not key:
+            raise ValueError(
+                "createSession requires a non-empty idempotencyKey so a retry can "
+                "find the existing session instead of starting a second paid one."
+            )
+        timeout = input.get("timeoutSeconds")
+        if timeout is not None and not integer(timeout, 60, 21600):
+            raise ValueError(
+                f"timeoutSeconds must be an integer between 60 and 21600, received {timeout}."
+            )
+        viewport = input.get("viewport")
+        if viewport is not None and not all(integer(viewport[k], 1) for k in ("width", "height")):
+            raise ValueError(
+                f"viewport width and height must be positive integers, received "
+                f"{viewport['width']}x{viewport['height']}."
+            )
+        existing = await self.api.call(
+            "/sessions?" + query({"q": f"user_metadata['{IDEMPOTENCY_METADATA_KEY}']:'{key}'"})
+        )
+        if existing:
+            return {**session(existing[0]), "created": False}
+        body = pick(input, "region", "keepAlive", "proxies")
+        project = input.get("projectId", self.env.get("BROWSERBASE_PROJECT_ID"))
+        if project is not None:
+            body["projectId"] = project
+        if timeout is not None:
+            body["timeout"] = timeout
+        body["userMetadata"] = {**input.get("userMetadata", {}), IDEMPOTENCY_METADATA_KEY: key}
+        settings = pick(
+            input,
+            "blockAds",
+            "solveCaptchas",
+            "recordSession",
+            "logSession",
+            "viewport",
+            "allowedDomains",
+        )
+        if "contextId" in input:
+            settings["context"] = {
+                "id": input["contextId"],
+                "persist": input.get("persistContext", False),
+            }
+        if settings:
+            body["browserSettings"] = settings
+        return {
+            **session(await self.api.call("/sessions", method="POST", body=body)),
+            "created": True,
+        }
+
+    async def get_session(self, input: t.SessionIdInput) -> t.SessionDTO:
+        return session(await self.api.call("/sessions/" + enc(input["sessionId"])))
+
+    async def close_session(self, input: t.SessionIdInput) -> t.CloseSessionResult:
+        current = await self.get_session(input)
+        changed = current["status"] not in ("ERROR", "TIMED_OUT", "COMPLETED")
+        if changed:
+            body = {"status": "REQUEST_RELEASE"}
+            if self.env.get("BROWSERBASE_PROJECT_ID"):
+                body["projectId"] = self.env["BROWSERBASE_PROJECT_ID"]
+            current = session(
+                await self.api.call(
+                    "/sessions/" + enc(input["sessionId"]), method="POST", body=body
+                )
+            )
+        return {"sessionId": current["sessionId"], "status": current["status"], "changed": changed}
+
+    @asynccontextmanager
+    async def page(self, session_id: str) -> AsyncIterator[Any]:
+        from playwright.async_api import async_playwright
+
+        debug = await self.api.call("/sessions/" + enc(session_id) + "/debug")
+        async with async_playwright() as playwright:
+            browser = await playwright.chromium.connect_over_cdp(debug["wsUrl"])
+            try:
+                if not browser.contexts:
+                    raise ValueError("No browser context on the session")
+                if not browser.contexts[0].pages:
+                    raise ValueError("No page on the session")
+                yield browser.contexts[0].pages[0]
+            finally:
+                await browser.close()
+
+    async def run_actions(self, input: t.RunActionsInput) -> t.RunActionsResult:
+        if not 1 <= len(input["actions"]) <= 50:
+            raise ValueError(
+                f"runActions accepts 1 to 50 actions, received {len(input['actions'])}."
+            )
+        timeout = input.get("actionTimeoutMs", 30000)
+        if not integer(timeout, 1, 120000):
+            raise ValueError(
+                f"actionTimeoutMs must be an integer between 1 and 120000, received {timeout}."
+            )
+        results: list[t.ActionResultDTO] = []
+        async with self.page(input["sessionId"]) as page:
+            page.set_default_timeout(timeout)
+            for index, action in enumerate(input["actions"]):
+                text = None
+                kind = action["type"]
+                if action["type"] == "goto":
+                    await page.goto(action["url"], wait_until=action.get("waitUntil", "load"))
+                elif action["type"] == "press":
+                    target = (
+                        page.locator(action["selector"])
+                        if action.get("selector")
+                        else page.keyboard
+                    )
+                    await target.press(action["key"])
+                elif action["type"] == "click":
+                    await page.locator(action["selector"]).click()
+                elif action["type"] == "fill":
+                    await page.locator(action["selector"]).fill(action["value"])
+                elif action["type"] == "select":
+                    await page.locator(action["selector"]).select_option(action["value"])
+                elif action["type"] == "waitForSelector":
+                    await page.locator(action["selector"]).wait_for(
+                        **({"state": action["state"]} if "state" in action else {})
+                    )
+                elif action["type"] == "extractText":
+                    text = bounded_text(
+                        await page.locator(action["selector"]).inner_text() or "",
+                        action.get("maxBytes", 262144),
+                    )
+                else:
+                    raise ValueError("Unsupported browser action")
+                results.append(
+                    {
+                        "index": index,
+                        "type": kind,
+                        "url": page.url,
+                        "title": await page.title(),
+                        "text": text,
+                    }
+                )
+        return {"sessionId": input["sessionId"], "actions": results}
+
+    async def capture_screenshot(
+        self, input: t.CaptureScreenshotInput
+    ) -> t.CaptureScreenshotResult:
+        format = input.get("format", "png")
+        quality = input.get("quality")
+        if quality is not None:
+            if format != "jpeg":
+                raise ValueError("quality is only valid for jpeg screenshots.")
+            if not integer(quality, 0, 100):
+                raise ValueError(
+                    f"quality must be an integer between 0 and 100, received {quality}."
+                )
+        maximum = validate_byte_limit(input.get("maxBytes", 524288), MAX_BINARY_BYTES)
+        async with self.page(input["sessionId"]) as page:
+            data = await page.screenshot(
+                full_page=input.get("fullPage", False),
+                type=format,
+                **({"quality": quality} if quality is not None else {}),
+            )
+        return {
+            "sessionId": input["sessionId"],
+            "screenshot": bounded_binary(data, "image/" + format, maximum),
+        }
+
+    async def upload_files(self, input: t.UploadFilesInput) -> t.UploadFilesResult:
+        if not input["files"]:
+            raise ValueError("uploadFiles requires at least one file.")
+        maximum = validate_byte_limit(input.get("maxTotalBytes", 1048576), MAX_BINARY_BYTES)
+        decoded = []
+        for file in input["files"]:
+            try:
+                data = base64.b64decode(
+                    file["base64"] + "=" * (-len(file["base64"]) % 4), validate=True
+                )
+                if base64.b64encode(data).decode().rstrip("=") != file["base64"].rstrip("="):
+                    raise ValueError("noncanonical base64")
+            except (ValueError, binascii.Error):
+                raise ValueError(f"File {file['name']} has invalid base64 content.") from None
+            decoded.append(data)
+        total = sum(map(len, decoded))
+        if total > maximum:
+            raise ValueError(
+                f"Uploads total {total} decoded bytes, above the maxTotalBytes "
+                f"limit of {maximum}. Upload fewer or smaller files."
+            )
+        for file, data in zip(input["files"], decoded, strict=True):
+            response = await self.http.post(
+                "https://api.browserbase.com/v1/sessions/" + enc(input["sessionId"]) + "/uploads",
+                headers=self._auth(),
+                files={"file": (file["name"], data, file["contentType"])},
+            )
+            if not response.is_success:
+                raise ApiError(response.status_code, "Browserbase file upload failed")
+        return {
+            "sessionId": input["sessionId"],
+            "files": [
+                {"name": file["name"], "contentType": file["contentType"], "byteCount": len(data)}
+                for file, data in zip(input["files"], decoded, strict=True)
+            ],
+        }
+
+    async def archive(self, session_id: str) -> zipfile.ZipFile:
+        # Keep compressed transfers bounded as well as extracted files.
+        async with self.http.stream(
+            "GET",
+            "https://api.browserbase.com/v1/sessions/" + enc(session_id) + "/downloads",
+            headers={**self._auth(), "Accept": "application/zip"},
+        ) as response:
+            if not response.is_success:
+                raise ApiError(response.status_code, "Browserbase downloads failed")
+            data = bytearray()
+            async for chunk in response.aiter_bytes():
+                if len(data) + len(chunk) > 104857600:
+                    raise ValueError(
+                        "Browserbase download archive exceeds the 100 MiB transfer limit."
+                    )
+                data.extend(chunk)
+        return zipfile.ZipFile(io.BytesIO(data))
+
+    async def list_downloads(self, input: t.ListDownloadsInput) -> t.ListDownloadsResult:
+        limit = max(1, min(100, int(input.get("limit", 20))))
+        offset = max(0, int(input.get("offset", 0)))
+        with await self.archive(input["sessionId"]) as archive:
+            all = [download(input["sessionId"], info) for info in archive.infolist()]
+        all = [item for item in all if all_match(item, input, ("filename", "contentType"))]
+        items = all[offset : offset + limit]
+        return {
+            "sessionId": input["sessionId"],
+            "downloads": items,
+            "page": {
+                "returned": len(items),
+                "available": len(all),
+                "limit": limit,
+                "truncated": offset + len(items) < len(all),
+            },
+        }
+
+    async def get_download(self, input: t.GetDownloadInput) -> t.GetDownloadResult:
+        maximum = validate_byte_limit(input.get("maxBytes", 1048576), MAX_BINARY_BYTES)
+        try:
+            value = input["downloadId"]
+            parsed = json.loads(base64.urlsafe_b64decode(value + "=" * (-len(value) % 4)))
+            session_id, name = parsed["sessionId"], parsed["name"]
+            if not isinstance(session_id, str) or not isinstance(name, str):
+                raise ValueError("invalid")
+        except (ValueError, KeyError, TypeError):
+            raise ValueError(f"Invalid downloadId: {input['downloadId']}") from None
+        with await self.archive(session_id) as archive:
+            try:
+                info = archive.getinfo(name)
+            except KeyError:
+                raise ValueError(f"Download not found: {name}") from None
+            metadata = download(session_id, info)
+            if info.file_size > maximum:
+                raise ValueError(
+                    f"Download {name} is {info.file_size} bytes, above the maxBytes "
+                    f"limit of {maximum}. Narrow the request or retrieve it from "
+                    f"the Browserbase-managed download URL directly."
+                )
+            with archive.open(info) as file:
+                data = file.read(maximum + 1)
+            return {**metadata, "content": bounded_binary(data, metadata["contentType"], maximum)}
+
+    async def get_session_logs(self, input: t.GetSessionLogsInput) -> t.GetSessionLogsResult:
+        limit = max(1, min(500, int(input.get("limit", 100))))
+        maximum = validate_byte_limit(input.get("maxBytes", 262144), MAX_TEXT_BYTES)
+        raw = await self.api.call("/sessions/" + enc(input["sessionId"]) + "/logs")
+        logs: list[t.SessionLogDTO] = []
+        used = 0
+        for log in raw[:limit]:
+            if used >= maximum:
+                break
+            request = log.get("request") or {}
+            response = log.get("response") or {}
+            bounded_request = bounded_text(
+                serialize(request.get("params"), request.get("rawBody", "")), maximum - used
+            )
+            used += bounded_request["returnedBytes"]
+            # A zero remaining budget must not leak another response byte.
+            response_text = serialize(response.get("result"), response.get("rawBody", ""))
+            bounded_response: BoundedText
+            if used == maximum:
+                bounded_response = {
+                    "text": "",
+                    "byteCount": len(response_text.encode()),
+                    "returnedBytes": 0,
+                    "maxBytes": 0,
+                    "truncated": bool(response_text),
+                }
+            else:
+                bounded_response = bounded_text(response_text, maximum - used)
+            used += bounded_response["returnedBytes"]
+            logs.append(
+                {
+                    "method": log["method"],
+                    "pageId": log["pageId"],
+                    "timestamp": log.get("timestamp"),
+                    "request": bounded_request,
+                    "response": bounded_response,
+                }
+            )
+        return {
+            "sessionId": input["sessionId"],
+            "logs": logs,
+            "page": {
+                "returned": len(logs),
+                "available": len(raw),
+                "limit": limit,
+                "truncated": len(logs) < len(raw)
+                or any(log["request"]["truncated"] or log["response"]["truncated"] for log in logs),
+            },
+        }
+
+    async def get_session_replay(self, input: t.GetSessionReplayInput) -> t.GetSessionReplayResult:
+        limit = max(1, min(100, int(input.get("limit", 20))))
+        raw = await self.api.call("/sessions/" + enc(input["sessionId"]) + "/replays")
+        pages: list[t.ReplayPageDTO] = [
+            {
+                "pageId": p["pageId"],
+                "startedAt": iso(p["startTimeMs"]) if p.get("startTimeMs") is not None else None,
+                "endedAt": iso(p["endTimeMs"]) if p.get("endTimeMs") is not None else None,
+                "playlistUrl": p["url"],
+            }
+            for p in raw["pages"][:limit]
+        ]
+        return {
+            "sessionId": input["sessionId"],
+            "pages": pages,
+            "page": {
+                "returned": len(pages),
+                "available": len(raw["pages"]),
+                "limit": limit,
+                "truncated": len(pages) < len(raw["pages"]),
+            },
+        }
+
+
+@asynccontextmanager
+async def dependencies(deps: Deps | None) -> AsyncIterator[Deps]:
+    if deps is not None:
+        yield deps
+    else:
+        async with httpx.AsyncClient(
+            timeout=30, transport=httpx.AsyncHTTPTransport(retries=0)
+        ) as http:
+            yield Deps(browserbase=Client(http))
+
+
+BrowserbasePort = Port
+BrowserbaseClient = Client
+BrowserbaseDeps = Deps

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/close_session.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_CONVERGENT_RETRY
+from .types import CloseSessionResult, SessionIdInput
+
+
+async def close_session_impl(
+    ctx: TaskContext, input: SessionIdInput, *, deps: Deps | None = None
+) -> CloseSessionResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.close_session(input)
+
+
+@app.task(name="browserbase.closeSession", retry=BROWSERBASE_CONVERGENT_RETRY)
+async def close_session(ctx: TaskContext, input: SessionIdInput) -> CloseSessionResult:
+    return await close_session_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/create_context.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_NO_RETRY
+from .types import CreateContextInput, CreateContextResult
+
+
+async def create_context_impl(
+    ctx: TaskContext, input: CreateContextInput, *, deps: Deps | None = None
+) -> CreateContextResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.create_context(input)
+
+
+@app.task(name="browserbase.createContext", retry=BROWSERBASE_NO_RETRY)
+async def create_context(ctx: TaskContext, input: CreateContextInput) -> CreateContextResult:
+    return await create_context_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/create_session.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_CONVERGENT_RETRY
+from .types import CreateSessionInput, CreateSessionResult
+
+
+async def create_session_impl(
+    ctx: TaskContext, input: CreateSessionInput, *, deps: Deps | None = None
+) -> CreateSessionResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.create_session(input)
+
+
+@app.task(name="browserbase.createSession", retry=BROWSERBASE_CONVERGENT_RETRY)
+async def create_session(ctx: TaskContext, input: CreateSessionInput) -> CreateSessionResult:
+    return await create_session_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/delete_context.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_CONVERGENT_RETRY
+from .types import DeleteContextInput, DeleteContextResult
+
+
+async def delete_context_impl(
+    ctx: TaskContext, input: DeleteContextInput, *, deps: Deps | None = None
+) -> DeleteContextResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.delete_context(input)
+
+
+@app.task(name="browserbase.deleteContext", retry=BROWSERBASE_CONVERGENT_RETRY)
+async def delete_context(ctx: TaskContext, input: DeleteContextInput) -> DeleteContextResult:
+    return await delete_context_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/get_download.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_READ_RETRY
+from .types import GetDownloadInput, GetDownloadResult
+
+
+async def get_download_impl(
+    ctx: TaskContext, input: GetDownloadInput, *, deps: Deps | None = None
+) -> GetDownloadResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.get_download(input)
+
+
+@app.task(name="browserbase.getDownload", retry=BROWSERBASE_READ_RETRY)
+async def get_download(ctx: TaskContext, input: GetDownloadInput) -> GetDownloadResult:
+    return await get_download_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/get_session.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_READ_RETRY
+from .types import SessionDTO, SessionIdInput
+
+
+async def get_session_impl(
+    ctx: TaskContext, input: SessionIdInput, *, deps: Deps | None = None
+) -> SessionDTO:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.get_session(input)
+
+
+@app.task(name="browserbase.getSession", retry=BROWSERBASE_READ_RETRY)
+async def get_session(ctx: TaskContext, input: SessionIdInput) -> SessionDTO:
+    return await get_session_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/get_session_logs.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_READ_RETRY
+from .types import GetSessionLogsInput, GetSessionLogsResult
+
+
+async def get_session_logs_impl(
+    ctx: TaskContext, input: GetSessionLogsInput, *, deps: Deps | None = None
+) -> GetSessionLogsResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.get_session_logs(input)
+
+
+@app.task(name="browserbase.getSessionLogs", retry=BROWSERBASE_READ_RETRY)
+async def get_session_logs(ctx: TaskContext, input: GetSessionLogsInput) -> GetSessionLogsResult:
+    return await get_session_logs_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/get_session_replay.py

@@ -0,0 +1,20 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_READ_RETRY
+from .types import GetSessionReplayInput, GetSessionReplayResult
+
+
+async def get_session_replay_impl(
+    ctx: TaskContext, input: GetSessionReplayInput, *, deps: Deps | None = None
+) -> GetSessionReplayResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.get_session_replay(input)
+
+
+@app.task(name="browserbase.getSessionReplay", retry=BROWSERBASE_READ_RETRY)
+async def get_session_replay(
+    ctx: TaskContext, input: GetSessionReplayInput
+) -> GetSessionReplayResult:
+    return await get_session_replay_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/list_downloads.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_READ_RETRY
+from .types import ListDownloadsInput, ListDownloadsResult
+
+
+async def list_downloads_impl(
+    ctx: TaskContext, input: ListDownloadsInput, *, deps: Deps | None = None
+) -> ListDownloadsResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.list_downloads(input)
+
+
+@app.task(name="browserbase.listDownloads", retry=BROWSERBASE_READ_RETRY)
+async def list_downloads(ctx: TaskContext, input: ListDownloadsInput) -> ListDownloadsResult:
+    return await list_downloads_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/retry.py

@@ -0,0 +1,5 @@
+from render import Retry
+
+BROWSERBASE_NO_RETRY = Retry(max_retries=0, wait_duration_ms=0, backoff_scaling=1)
+BROWSERBASE_CONVERGENT_RETRY = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2)
+BROWSERBASE_READ_RETRY = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/run_actions.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_NO_RETRY
+from .types import RunActionsInput, RunActionsResult
+
+
+async def run_actions_impl(
+    ctx: TaskContext, input: RunActionsInput, *, deps: Deps | None = None
+) -> RunActionsResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.run_actions(input)
+
+
+@app.task(name="browserbase.runActions", retry=BROWSERBASE_NO_RETRY)
+async def run_actions(ctx: TaskContext, input: RunActionsInput) -> RunActionsResult:
+    return await run_actions_impl(ctx, input)

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/tasks.py

@@ -0,0 +1,41 @@
+from ._app import app
+from .capture_screenshot import capture_screenshot, capture_screenshot_impl
+from .close_session import close_session, close_session_impl
+from .create_context import create_context, create_context_impl
+from .create_session import create_session, create_session_impl
+from .delete_context import delete_context, delete_context_impl
+from .get_download import get_download, get_download_impl
+from .get_session import get_session, get_session_impl
+from .get_session_logs import get_session_logs, get_session_logs_impl
+from .get_session_replay import get_session_replay, get_session_replay_impl
+from .list_downloads import list_downloads, list_downloads_impl
+from .run_actions import run_actions, run_actions_impl
+from .upload_files import upload_files, upload_files_impl
+
+__all__ = [
+    "app",
+    "capture_screenshot",
+    "capture_screenshot_impl",
+    "close_session",
+    "close_session_impl",
+    "create_context",
+    "create_context_impl",
+    "create_session",
+    "create_session_impl",
+    "delete_context",
+    "delete_context_impl",
+    "get_download",
+    "get_download_impl",
+    "get_session",
+    "get_session_impl",
+    "get_session_logs",
+    "get_session_logs_impl",
+    "get_session_replay",
+    "get_session_replay_impl",
+    "list_downloads",
+    "list_downloads_impl",
+    "run_actions",
+    "run_actions_impl",
+    "upload_files",
+    "upload_files_impl",
+]

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/types.py

@@ -0,0 +1,288 @@
+"""JSON contracts ported from the pinned TypeScript pack."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, NotRequired, TypedDict
+
+from render_lab_tasks_core.bounded import BoundedBinary, BoundedText
+
+
+class UploadFilesResultFilesItem(TypedDict):
+    name: str
+    contentType: str
+    byteCount: float
+
+
+class BrowserActionValueVariant7(TypedDict):
+    type: Literal["extractText"]
+    selector: str
+    maxBytes: NotRequired[float]
+
+
+class BrowserActionValueVariant6(TypedDict):
+    type: Literal["waitForSelector"]
+    selector: str
+    state: NotRequired[
+        Literal["attached"] | Literal["detached"] | Literal["visible"] | Literal["hidden"]
+    ]
+
+
+class BrowserActionValueVariant5(TypedDict):
+    type: Literal["select"]
+    selector: str
+    value: str
+
+
+class BrowserActionValueVariant4(TypedDict):
+    type: Literal["press"]
+    selector: NotRequired[str]
+    key: str
+
+
+class BrowserActionValueVariant3(TypedDict):
+    type: Literal["fill"]
+    selector: str
+    value: str
+
+
+class BrowserActionValueVariant2(TypedDict):
+    type: Literal["click"]
+    selector: str
+
+
+class BrowserActionValueVariant1(TypedDict):
+    type: Literal["goto"]
+    url: str
+    waitUntil: NotRequired[Literal["load"] | Literal["domcontentloaded"] | Literal["networkidle"]]
+
+
+class CreateSessionInputViewport(TypedDict):
+    width: float
+    height: float
+
+
+type SessionStatus = (
+    Literal["PENDING"]
+    | Literal["RUNNING"]
+    | Literal["ERROR"]
+    | Literal["TIMED_OUT"]
+    | Literal["COMPLETED"]
+)
+
+type BrowserbaseRegion = (
+    Literal["us-west-2"]
+    | Literal["us-east-1"]
+    | Literal["eu-central-1"]
+    | Literal["ap-southeast-1"]
+)
+
+
+class ContextDTO(TypedDict):
+    contextId: str
+    projectId: str
+    createdAt: str
+    updatedAt: str
+
+
+class CreateContextInput(TypedDict):
+    projectId: NotRequired[str]
+
+
+class CreateContextResult(TypedDict):
+    contextId: str
+
+
+class DeleteContextInput(TypedDict):
+    contextId: str
+
+
+class DeleteContextResult(TypedDict):
+    contextId: str
+    deleted: bool
+
+
+class SessionDTO(TypedDict):
+    sessionId: str
+    projectId: str
+    status: SessionStatus
+    contextId: str | None
+    region: BrowserbaseRegion
+    keepAlive: bool
+    createdAt: str
+    updatedAt: str
+    startedAt: str
+    expiresAt: str
+
+
+class CreateSessionInput(TypedDict):
+    idempotencyKey: str
+    projectId: NotRequired[str]
+    contextId: NotRequired[str]
+    persistContext: NotRequired[bool]
+    region: NotRequired[BrowserbaseRegion]
+    keepAlive: NotRequired[bool]
+    timeoutSeconds: NotRequired[float]
+    proxies: NotRequired[bool]
+    blockAds: NotRequired[bool]
+    solveCaptchas: NotRequired[bool]
+    recordSession: NotRequired[bool]
+    logSession: NotRequired[bool]
+    viewport: NotRequired[CreateSessionInputViewport]
+    allowedDomains: NotRequired[list[str]]
+    userMetadata: NotRequired[dict[str, str]]
+
+
+class CreateSessionResult(SessionDTO):
+    created: bool
+
+
+class SessionIdInput(TypedDict):
+    sessionId: str
+
+
+class CloseSessionResult(TypedDict):
+    sessionId: str
+    status: SessionStatus
+    changed: bool
+
+
+type BrowserAction = (
+    BrowserActionValueVariant1
+    | BrowserActionValueVariant2
+    | BrowserActionValueVariant3
+    | BrowserActionValueVariant4
+    | BrowserActionValueVariant5
+    | BrowserActionValueVariant6
+    | BrowserActionValueVariant7
+)
+
+
+class RunActionsInput(SessionIdInput):
+    actions: list[BrowserAction]
+    actionTimeoutMs: NotRequired[float]
+
+
+class ActionResultDTO(TypedDict):
+    index: float
+    type: Literal["goto", "click", "fill", "press", "select", "waitForSelector", "extractText"]
+    url: str
+    title: str
+    text: BoundedText | None
+
+
+class RunActionsResult(TypedDict):
+    sessionId: str
+    actions: list[ActionResultDTO]
+
+
+class CaptureScreenshotInput(SessionIdInput):
+    fullPage: NotRequired[bool]
+    format: NotRequired[Literal["png"] | Literal["jpeg"]]
+    quality: NotRequired[float]
+    maxBytes: NotRequired[float]
+
+
+class CaptureScreenshotResult(TypedDict):
+    sessionId: str
+    screenshot: BoundedBinary
+
+
+class UploadFileInput(TypedDict):
+    name: str
+    contentType: str
+    base64: str
+
+
+class UploadFilesInput(SessionIdInput):
+    files: list[UploadFileInput]
+    maxTotalBytes: NotRequired[float]
+
+
+class UploadFilesResult(TypedDict):
+    sessionId: str
+    files: list[UploadFilesResultFilesItem]
+
+
+class DownloadDTO(TypedDict):
+    downloadId: str
+    sessionId: str
+    filename: str
+    contentType: str
+    byteCount: float
+    checksum: str
+    createdAt: str
+
+
+class ListDownloadsInput(SessionIdInput):
+    filename: NotRequired[str]
+    contentType: NotRequired[str]
+    limit: NotRequired[float]
+    offset: NotRequired[float]
+
+
+class ListDownloadsResult(TypedDict):
+    sessionId: str
+    downloads: list[DownloadDTO]
+    page: BoundedCollection
+
+
+class GetDownloadInput(TypedDict):
+    downloadId: str
+    maxBytes: NotRequired[float]
+
+
+class GetDownloadResult(DownloadDTO):
+    content: BoundedBinary
+
+
+class GetSessionLogsInput(SessionIdInput):
+    limit: NotRequired[float]
+    maxBytes: NotRequired[float]
+
+
+class SessionLogDTO(TypedDict):
+    method: str
+    pageId: float
+    timestamp: float | None
+    request: BoundedText
+    response: BoundedText
+
+
+class GetSessionLogsResult(TypedDict):
+    sessionId: str
+    logs: list[SessionLogDTO]
+    page: BoundedCollection
+
+
+class GetSessionReplayInput(SessionIdInput):
+    limit: NotRequired[float]
+
+
+class ReplayPageDTO(TypedDict):
+    pageId: str
+    startedAt: str | None
+    endedAt: str | None
+    playlistUrl: str
+
+
+class GetSessionReplayResult(TypedDict):
+    sessionId: str
+    pages: list[ReplayPageDTO]
+    page: BoundedCollection
+
+
+class RawSessionLog(TypedDict):
+    method: str
+    pageId: float
+    timestamp: float | None
+    requestParams: Any
+    requestBody: str
+    responseResult: Any
+    responseBody: str
+
+
+class BoundedCollection(TypedDict):
+    returned: int
+    available: int | None
+    limit: int
+    truncated: bool

render_lab_tasks_browserbase-0.1.0/src/render_lab_tasks_browserbase/upload_files.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import BROWSERBASE_NO_RETRY
+from .types import UploadFilesInput, UploadFilesResult
+
+
+async def upload_files_impl(
+    ctx: TaskContext, input: UploadFilesInput, *, deps: Deps | None = None
+) -> UploadFilesResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.browserbase.upload_files(input)
+
+
+@app.task(name="browserbase.uploadFiles", retry=BROWSERBASE_NO_RETRY)
+async def upload_files(ctx: TaskContext, input: UploadFilesInput) -> UploadFilesResult:
+    return await upload_files_impl(ctx, input)