gumloop 0.4.9__tar.gz → 0.5.0__tar.gz

{gumloop-0.4.9 → gumloop-0.5.0}/.github/workflows/ci.yml

@@ -25,10 +25,12 @@ jobs:
       - run: uv run --frozen ruff format --check .
       - run: uv run --frozen ruff check .
       - run: uv lock --check
-      - name: Check install.sh syntax
+      - name: Check installer script syntax
         run: |
-          sh -n scripts/install.sh
-          bash -n scripts/install.sh
+          for script in scripts/install.sh scripts/import-logins.sh; do
+            sh -n "$script"
+            bash -n "$script"
+          done
 
   typecheck:
     runs-on: ubuntu-latest

{gumloop-0.4.9 → gumloop-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gumloop
-Version: 0.4.9
+Version: 0.5.0
 Summary: Python client for the Gumloop API
 Project-URL: Homepage, https://github.com/gumloop/gumloop-py
 Project-URL: Bug Tracker, https://github.com/gumloop/gumloop-py/issues
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0
+Requires-Dist: cryptography>=42.0.0
 Requires-Dist: httpx-sse>=0.4.0
 Requires-Dist: httpx>=0.24.1
 Requires-Dist: keyring>=24
@@ -41,6 +42,26 @@ The installer is fully self-contained under `~/.gumloop` — it ships its own Py
 gumloop update
 ```
 
+### Import your browser sign-ins into a browser profile
+
+Gumloop agents that use the Browser ability keep their sign-ins in a **browser profile**. Import the sites you are already signed into locally (Chrome, Brave, Edge, Chromium, Arc, Firefox on macOS or Linux) without an extension. By default every site in the local browser profile you pick comes across; you see the sites and cookie counts and confirm before anything is sent:
+
+```bash
+gumloop browser import-logins                                          # every site, into your personal default profile
+gumloop browser import-logins --browser brave --exclude-domain doubleclick.net
+gumloop browser import-logins --include-domain github.com --include-domain linear.app
+gumloop browser import-logins --url https://mail.google.com --team <team_id> --into 'Ops inbox'   # one site
+gumloop browser profiles list
+```
+
+Or, without installing anything first (set `GUMLOOP_LOGIN_URL` to import a single site, `GUMLOOP_EXCLUDE_DOMAINS` / `GUMLOOP_INCLUDE_DOMAINS` to narrow a whole-profile import):
+
+```bash
+curl -fsSL https://gumloop.com/cli/import-logins.sh | sh
+```
+
+Cookies only: local storage and IndexedDB stay on your machine, so sites that keep the session there ask the agent to sign in once, after which the agent's browser keeps it. Imported cookies are encrypted with the profile's own key before storage and are never shown back in the UI or API; sign-ins the agent picks up while running are saved back to the same profile. Rename, remove sites from, or delete profiles on the Secrets page in Gumloop.
+
 ## SDK
 
 To use the client as a library in your own Python project:
@@ -115,3 +136,22 @@ async def main() -> None:
 
 asyncio.run(main())
 ```
+
+## Route a task to the right model
+
+Ask Gumloop Chew which of your candidate models should handle a task. Decision only — nothing runs.
+
+```python
+from gumloop import Gumloop
+
+client = Gumloop(api_key="your_api_key", user_id="your_user_id")
+
+decision = client.models.route(
+    input="Summarize this email thread and draft a reply",
+    models=["gpt-5.6-luna", "x-ai/grok-4.6", "claude-opus-5"],
+)
+
+print(decision.route.model, decision.route.lane, decision.route.fallback_models)
+```
+
+Omit `models` to route across the full Chew catalog. Each call bills one small classifier completion.

gumloop-0.5.0/README.md

@@ -0,0 +1,131 @@
+# Gumloop Python Client
+
+A Python client for the Gumloop API that makes it easy to run and monitor Gumloop flows, plus the `gumloop` CLI.
+
+## CLI
+
+Install on macOS or Linux:
+
+```bash
+curl -fsSL https://gumloop.com/cli/install.sh | sh
+```
+
+The installer is fully self-contained under `~/.gumloop` — it ships its own Python, never touches your system Python, and needs no sudo. Run `gumloop --help` to get started and update any time with:
+
+```bash
+gumloop update
+```
+
+### Import your browser sign-ins into a browser profile
+
+Gumloop agents that use the Browser ability keep their sign-ins in a **browser profile**. Import the sites you are already signed into locally (Chrome, Brave, Edge, Chromium, Arc, Firefox on macOS or Linux) without an extension. By default every site in the local browser profile you pick comes across; you see the sites and cookie counts and confirm before anything is sent:
+
+```bash
+gumloop browser import-logins                                          # every site, into your personal default profile
+gumloop browser import-logins --browser brave --exclude-domain doubleclick.net
+gumloop browser import-logins --include-domain github.com --include-domain linear.app
+gumloop browser import-logins --url https://mail.google.com --team <team_id> --into 'Ops inbox'   # one site
+gumloop browser profiles list
+```
+
+Or, without installing anything first (set `GUMLOOP_LOGIN_URL` to import a single site, `GUMLOOP_EXCLUDE_DOMAINS` / `GUMLOOP_INCLUDE_DOMAINS` to narrow a whole-profile import):
+
+```bash
+curl -fsSL https://gumloop.com/cli/import-logins.sh | sh
+```
+
+Cookies only: local storage and IndexedDB stay on your machine, so sites that keep the session there ask the agent to sign in once, after which the agent's browser keeps it. Imported cookies are encrypted with the profile's own key before storage and are never shown back in the UI or API; sign-ins the agent picks up while running are saved back to the same profile. Rename, remove sites from, or delete profiles on the Secrets page in Gumloop.
+
+## SDK
+
+To use the client as a library in your own Python project:
+
+```bash
+uv add gumloop
+```
+
+## Usage
+
+```python
+from gumloop import GumloopClient
+
+# Initialize the client
+client = GumloopClient(
+    api_key="your_api_key",
+    user_id="your_user_id"
+)
+
+# Run a flow and wait for outputs
+output = client.run_flow(
+    flow_id="your_flow_id",
+    inputs={
+        "recipient": "example@email.com",
+        "subject": "Hello",
+        "body": "World"
+    }
+)
+
+print(output)
+```
+
+## Authenticate with a team API key
+
+Team (workspace) API keys are scoped to a single team. Pass the team's ID and
+the acting member's user ID — every request is validated against that team and
+only reaches resources the team owns.
+
+```python
+from gumloop import Gumloop
+
+client = Gumloop(
+    api_key="your_team_api_key",
+    user_id="your_user_id",  # must be a member of the team
+    team_id="your_team_id",
+)
+
+agents = client.agents.list()  # scoped to the team
+```
+
+`team_id` can also be provided via the `GUMLOOP_TEAM_ID` environment variable.
+
+## Chat with an agent (streaming)
+
+```python
+import asyncio
+
+from gumloop import AsyncGumloop
+
+
+async def main() -> None:
+    async with AsyncGumloop(access_token="your_access_token") as client:
+        agents = await client.agents.list()
+        agent = agents.agents[0]
+
+        async for event in client.sessions.stream(
+            agent.id,
+            input="Hello, what can you do?",
+        ):
+            print(event)
+
+
+asyncio.run(main())
+```
+
+## Route a task to the right model
+
+Ask Gumloop Chew which of your candidate models should handle a task. Decision only — nothing runs.
+
+```python
+from gumloop import Gumloop
+
+client = Gumloop(api_key="your_api_key", user_id="your_user_id")
+
+decision = client.models.route(
+    input="Summarize this email thread and draft a reply",
+    models=["gpt-5.6-luna", "x-ai/grok-4.6", "claude-opus-5"],
+)
+
+print(decision.route.model, decision.route.lane, decision.route.fallback_models)
+```
+
+Omit `models` to route across the full Chew catalog. Each call bills one small classifier completion.

{gumloop-0.4.9 → gumloop-0.5.0}/pyproject.toml

@@ -19,6 +19,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
+    "cryptography>=42.0.0",
     "httpx>=0.24.1",
     "httpx-sse>=0.4.0",
     "keyring>=24",

gumloop-0.5.0/scripts/import-logins.sh

@@ -0,0 +1,93 @@
+#!/bin/sh
+# Bring this machine's browser sign-ins into your Gumloop browser profile (every site, cookies only):
+#   curl -fsSL https://gumloop.com/cli/import-logins.sh | sh
+# One site only:
+#   GUMLOOP_LOGIN_URL='https://app.example.com' sh -c 'curl -fsSL https://gumloop.com/cli/import-logins.sh | sh'
+
+set -eu
+
+INSTALL_URL="${GUMLOOP_INSTALL_URL:-https://gumloop.com/cli/install.sh}"
+GUMLOOP_HOME="${GUMLOOP_INSTALL_DIR:-$HOME/.gumloop}"
+SHIM_PATH="$HOME/.local/bin/gumloop"
+
+if [ -t 1 ]; then
+    BOLD="$(printf '\033[1m')"
+    RED="$(printf '\033[31m')"
+    RESET="$(printf '\033[0m')"
+else
+    BOLD="" RED="" RESET=""
+fi
+
+step() { printf '%s==>%s %s\n' "${BOLD}" "${RESET}" "$1"; }
+fail() { printf '%serror:%s %s\n' "${RED}" "${RESET}" "$1" >&2; exit 1; }
+
+# Prompts read /dev/tty, not stdin: under `curl | sh` stdin is the script.
+has_tty() { ( : < /dev/tty ) 2>/dev/null; }
+
+case "$(uname -s)" in
+    Darwin|Linux) ;;
+    *) fail "the Gumloop CLI runs on macOS and Linux. On Windows, use the Gumloop Chrome extension from the Secrets page instead." ;;
+esac
+
+find_cli() {
+    if [ -x "$SHIM_PATH" ]; then
+        printf '%s' "$SHIM_PATH"
+    elif [ -x "$GUMLOOP_HOME/venv/bin/gumloop" ]; then
+        printf '%s' "$GUMLOOP_HOME/venv/bin/gumloop"
+    elif command -v gumloop >/dev/null 2>&1; then
+        command -v gumloop
+    fi
+}
+
+CLI="$(find_cli || true)"
+if [ -z "$CLI" ]; then
+    step "Installing the Gumloop CLI"
+    if command -v curl >/dev/null 2>&1; then
+        curl -fsSL "$INSTALL_URL" | GUMLOOP_SKIP_LOGIN=1 sh
+    elif command -v wget >/dev/null 2>&1; then
+        wget -qO- "$INSTALL_URL" | GUMLOOP_SKIP_LOGIN=1 sh
+    else
+        fail "curl or wget is required"
+    fi
+    CLI="$(find_cli || true)"
+    [ -n "$CLI" ] || fail "the Gumloop CLI did not install; see the messages above."
+fi
+
+if ! "$CLI" browser --help >/dev/null 2>&1; then
+    step "Updating the Gumloop CLI (this version cannot import sites)"
+    "$CLI" update >/dev/null 2>&1 || fail "could not update the Gumloop CLI; run '$CLI update' and retry."
+fi
+
+url="${GUMLOOP_LOGIN_URL:-}"
+
+if [ -z "${GUMLOOP_API_KEY:-}" ] && [ -z "${GUMLOOP_ACCESS_TOKEN:-}" ]; then
+    if ! "$CLI" browser profiles list --json >/dev/null 2>&1; then
+        step "Signing in to Gumloop"
+        has_tty || fail "not signed in and no terminal to sign in on. Set GUMLOOP_API_KEY and GUMLOOP_USER_ID, or run 'gumloop login' first."
+        "$CLI" login < /dev/tty
+    fi
+fi
+
+set -- browser import-logins
+if [ -n "$url" ]; then
+    set -- "$@" --url "$url" --yes
+else
+    # A whole profile is previewed and confirmed on the terminal; headless runs have already opted in.
+    has_tty || set -- "$@" --yes
+    for domain in $(printf '%s' "${GUMLOOP_INCLUDE_DOMAINS:-}" | tr ',' ' '); do set -- "$@" --include-domain "$domain"; done
+    for domain in $(printf '%s' "${GUMLOOP_EXCLUDE_DOMAINS:-}" | tr ',' ' '); do set -- "$@" --exclude-domain "$domain"; done
+fi
+[ -n "${GUMLOOP_BROWSER_PROFILE_ID:-}" ] && set -- "$@" --into "$GUMLOOP_BROWSER_PROFILE_ID"
+[ -n "${GUMLOOP_TEAM_ID:-}" ] && set -- "$@" --team "$GUMLOOP_TEAM_ID"
+[ -n "${GUMLOOP_BROWSER:-}" ] && set -- "$@" --browser "$GUMLOOP_BROWSER"
+
+if [ -n "$url" ]; then
+    step "Importing your sign-in for ${url}"
+else
+    step "Importing your browser's sign-ins"
+fi
+if has_tty; then
+    "$CLI" "$@" < /dev/tty
+else
+    "$CLI" "$@"
+fi

{gumloop-0.4.9 → gumloop-0.5.0}/scripts/install.sh

@@ -279,7 +279,7 @@ case "$login_state" in
         printf 'or install a keychain (e.g. apt install gnome-keyring libsecret-1-0) and run `gumloop login`.\n\n'
         ;;
     *)
-        if has_tty && confirm "Log in to Gumloop now?"; then
+        if [ -z "${GUMLOOP_SKIP_LOGIN:-}" ] && has_tty && confirm "Log in to Gumloop now?"; then
             "$SHIM_PATH" login < /dev/tty || true
         fi
         ;;

{gumloop-0.4.9 → gumloop-0.5.0}/src/gumloop/_client.py

@@ -18,15 +18,21 @@ from gumloop.resources import Artifacts
 from gumloop.resources import AsyncAgents
 from gumloop.resources import AsyncArtifacts
 from gumloop.resources import AsyncBrain
+from gumloop.resources import AsyncBrowserProfiles
 from gumloop.resources import AsyncChat
+from gumloop.resources import AsyncEvaluations
 from gumloop.resources import AsyncMCP
 from gumloop.resources import AsyncModels
+from gumloop.resources import AsyncOrganizations
 from gumloop.resources import AsyncSessions
 from gumloop.resources import AsyncSkills
 from gumloop.resources import AsyncTeams
 from gumloop.resources import Brain
+from gumloop.resources import BrowserProfiles
 from gumloop.resources import Chat
+from gumloop.resources import Evaluations
 from gumloop.resources import Models
+from gumloop.resources import Organizations
 from gumloop.resources import Sessions
 from gumloop.resources import Skills
 from gumloop.resources import Sync
@@ -46,7 +52,8 @@ def _derive_stream_base_url(base_url: str) -> str:
 class Gumloop:
     """Sync Gumloop SDK client. Composes an :class:`HttpClient` with the
     resource classes (``agents``, ``sessions``, ``mcp``, ``teams``,
-    ``skills``, ``artifacts``, ``brain``, ``models``). The :attr:`oauth`
+    ``organizations``, ``evaluations``, ``skills``, ``artifacts``, ``brain``,
+    ``models``). The :attr:`oauth`
     attribute holds OAuth helpers — kept off the transport because it
     bootstraps the bearer token rather than consuming one."""
 
@@ -92,10 +99,13 @@ class Gumloop:
         self.models = Models(self._http)
         self.mcp = MCP(self._http)
         self.teams = Teams(self._http)
+        self.organizations = Organizations(self._http)
+        self.evaluations = Evaluations(self._http)
         self.skills = Skills(self._http)
         self.sync = Sync(self._http)
         self.artifacts = Artifacts(self._http)
         self.brain = Brain(self._http)
+        self.browser_profiles = BrowserProfiles(self._http)
         self.oauth = OAuth(base_url=self.base_url, timeout=self.timeout)
 
     def close(self) -> None:
@@ -151,9 +161,12 @@ class AsyncGumloop:
         self.models = AsyncModels(self._http)
         self.mcp = AsyncMCP(self._http)
         self.teams = AsyncTeams(self._http)
+        self.organizations = AsyncOrganizations(self._http)
+        self.evaluations = AsyncEvaluations(self._http)
         self.skills = AsyncSkills(self._http)
         self.artifacts = AsyncArtifacts(self._http)
         self.brain = AsyncBrain(self._http)
+        self.browser_profiles = AsyncBrowserProfiles(self._http)
         self.oauth = OAuth(base_url=self.base_url, timeout=self.timeout)
 
     async def __aenter__(self) -> AsyncGumloop:

{gumloop-0.4.9 → gumloop-0.5.0}/src/gumloop/_version.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.4.9"
+__version__ = "0.5.0"

gumloop-0.5.0/src/gumloop/browser_logins/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from gumloop.browser_logins.discovery import BrowserKind
+from gumloop.browser_logins.discovery import LocalProfile
+from gumloop.browser_logins.discovery import discover_profiles
+from gumloop.browser_logins.extract import ExtractResult
+from gumloop.browser_logins.extract import extract_profile_cookies
+from gumloop.browser_logins.extract import extract_site_cookies
+from gumloop.browser_logins.filter import site_of_url
+
+__all__ = [
+    "BrowserKind",
+    "ExtractResult",
+    "LocalProfile",
+    "discover_profiles",
+    "extract_profile_cookies",
+    "extract_site_cookies",
+    "site_of_url",
+]

gumloop-0.5.0/src/gumloop/browser_logins/chromium_cookies.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import hashlib
+import shutil
+import sqlite3
+import subprocess
+import sys
+import tempfile
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.ciphers import Cipher
+from cryptography.hazmat.primitives.ciphers import algorithms
+from cryptography.hazmat.primitives.ciphers import modes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+from gumloop.browser_logins.discovery import BrowserKind
+
+_SALT = b"saltysalt"
+_IV = b" " * 16
+_KEY_LENGTH = 16
+_MAC_ITERATIONS = 1003
+_LINUX_ITERATIONS = 1
+_LINUX_DEFAULT_PASSWORD = b"peanuts"
+_WEBKIT_EPOCH_OFFSET_US = 11_644_473_600 * 1_000_000
+_SAME_SITE = {0: "None", 1: "Lax", 2: "Strict"}
+
+_QUERY = (
+    "SELECT host_key, name, value, encrypted_value, path, expires_utc, is_secure, is_httponly, "
+    "samesite, has_expires, top_frame_site_key FROM cookies"
+)
+
+
+class KeychainAccessError(RuntimeError):
+    """The OS refused to hand over the browser's cookie encryption key."""
+
+
+@dataclass
+class ChromiumReadResult:
+    cookies: list[dict[str, Any]]
+    undecryptable: int = 0
+
+
+def macos_safe_storage_password(
+    service: str, runner: Callable[..., subprocess.CompletedProcess] = subprocess.run
+) -> bytes:
+    completed = runner(
+        ["security", "find-generic-password", "-w", "-s", service],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if completed.returncode != 0 or not completed.stdout.strip():
+        raise KeychainAccessError(
+            f"macOS Keychain did not release the '{service}' key (was the prompt denied?). "
+            "Allow access when macOS asks, or use the Gumloop Chrome extension instead."
+        )
+
+    return completed.stdout.strip().encode("utf-8")
+
+
+def linux_safe_storage_password(service: str) -> bytes:
+    try:
+        import secretstorage  # type: ignore[import-not-found]  # noqa: PLC0415 - optional, desktop-only dependency
+
+        connection = secretstorage.dbus_init()
+        collection = secretstorage.get_default_collection(connection)
+        for item in collection.get_all_items():
+            if item.get_label() == service:
+                secret = item.get_secret()
+                if secret:
+                    return bytes(secret)
+    except Exception:  # noqa: BLE001 - no bus, no keyring, no secretstorage: fall back to the default key
+        pass
+
+    return _LINUX_DEFAULT_PASSWORD
+
+
+def derive_key(password: bytes, *, iterations: int) -> bytes:
+    kdf = PBKDF2HMAC(algorithm=hashes.SHA1(), length=_KEY_LENGTH, salt=_SALT, iterations=iterations)
+    return kdf.derive(password)
+
+
+def resolve_key(browser: BrowserKind, *, platform: str | None = None) -> bytes:
+    platform = platform or sys.platform
+    if platform == "darwin":
+        return derive_key(macos_safe_storage_password(browser.safe_storage_service), iterations=_MAC_ITERATIONS)
+
+    return derive_key(linux_safe_storage_password(browser.safe_storage_service), iterations=_LINUX_ITERATIONS)
+
+
+def decrypt_value(encrypted: bytes, key: bytes, host_key: str) -> str | None:
+    """Chrome 130+ prefixes the plaintext with SHA-256(host_key)."""
+    if len(encrypted) < 3:
+        return None
+
+    prefix, body = encrypted[:3], encrypted[3:]
+    if prefix not in (b"v10", b"v11"):
+        return None
+
+    if len(body) % 16 != 0 or not body:
+        return None
+
+    decryptor = Cipher(algorithms.AES(key), modes.CBC(_IV)).decryptor()
+    padded = decryptor.update(body) + decryptor.finalize()
+    pad = padded[-1]
+    if pad < 1 or pad > 16 or padded[-pad:] != bytes([pad]) * pad:
+        return None
+
+    plain = padded[:-pad]
+    host_hash = hashlib.sha256(host_key.encode("utf-8")).digest()
+    if plain[:32] == host_hash:
+        plain = plain[32:]
+
+    try:
+        return plain.decode("utf-8")
+    except UnicodeDecodeError:
+        return None
+
+
+def _webkit_to_unix(expires_utc: int) -> float | None:
+    if not expires_utc:
+        return None
+
+    return (expires_utc - _WEBKIT_EPOCH_OFFSET_US) / 1_000_000
+
+
+def copy_database(db_path: Path) -> tuple[Path, Path]:
+    """Copy the database (and its journal/WAL) so a running browser's lock does not matter."""
+    temp_dir = Path(tempfile.mkdtemp(prefix="gumloop-cookies-"))
+    copied = temp_dir / db_path.name
+    shutil.copy2(db_path, copied)
+    for suffix in ("-journal", "-wal", "-shm"):
+        sidecar = db_path.with_name(db_path.name + suffix)
+        if sidecar.exists():
+            shutil.copy2(sidecar, temp_dir / sidecar.name)
+
+    return temp_dir, copied
+
+
+def read_cookies(db_path: Path, key: bytes | None, *, keep: Callable[[str], bool] | None = None) -> ChromiumReadResult:
+    """Cookies as CDP ``CookieParam``-shaped dicts; ``keep(host_key)`` filters before any value is decrypted."""
+    temp_dir, copied = copy_database(db_path)
+    try:
+        connection = sqlite3.connect(f"file:{copied}?mode=ro", uri=True)
+        try:
+            rows = connection.execute(_QUERY).fetchall()
+        finally:
+            connection.close()
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+    cookies: list[dict[str, Any]] = []
+    undecryptable = 0
+    for (
+        host_key,
+        name,
+        value,
+        encrypted_value,
+        path,
+        expires_utc,
+        is_secure,
+        is_httponly,
+        samesite,
+        has_expires,
+        top_frame,
+    ) in rows:
+        if keep is not None and not keep(host_key):
+            continue
+
+        plain = value or ""
+        if not plain and encrypted_value:
+            decrypted = decrypt_value(bytes(encrypted_value), key, host_key) if key is not None else None
+            if decrypted is None:
+                undecryptable += 1
+                continue
+
+            plain = decrypted
+
+        cookie: dict[str, Any] = {
+            "name": name,
+            "value": plain,
+            "domain": host_key,
+            "path": path or "/",
+            "secure": bool(is_secure),
+            "httpOnly": bool(is_httponly),
+        }
+        same_site = _SAME_SITE.get(samesite)
+        if same_site:
+            cookie["sameSite"] = same_site
+
+        if has_expires:
+            expires = _webkit_to_unix(expires_utc)
+            if expires:
+                cookie["expires"] = expires
+
+        if top_frame:
+            cookie["partitionKey"] = {"topLevelSite": top_frame}
+
+        cookies.append(cookie)
+
+    return ChromiumReadResult(cookies=cookies, undecryptable=undecryptable)