@openhands/extensions 0.5.0 → 0.7.0

package/skills/slack-channel-monitor/scripts/main.py

@@ -40,11 +40,10 @@ import urllib.request
 from datetime import datetime, timezone
 from urllib.parse import urlencode
 
-# ── Debug logging to a persistent file ────────────────────────────────────────
+# ── Debug logging to a per-run file ───────────────────────────────────────────
 _DEBUG_LOG_PATH = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.abspath(
-        os.environ.get("WORKSPACE_BASE", "/tmp")))),
-    "automation-state", "slack_poller_debug.log",
+    os.environ.get("WORKSPACE_BASE", "/tmp"),
+    "slack_poller_debug.log",
 )
 os.makedirs(os.path.dirname(_DEBUG_LOG_PATH), exist_ok=True)
 _debug_log_fh = open(_DEBUG_LOG_PATH, "a")
@@ -198,14 +197,47 @@ def fire_callback(
         print(f"Callback error (non-fatal): {exc}")
 
 
-# ── State management ───────────────────────────────────────────────────────────
+# ── State persistence (KV store with local-file fallback) ─────────────────────
 
-def _state_file_path() -> str:
-    """Derive a persistent storage path from WORKSPACE_BASE.
+_KV_TOKEN = os.environ.get("AUTOMATION_KV_TOKEN", "")
+_KV_BASE = os.environ.get("AUTOMATION_API_URL", "").rstrip("/")
+_STATE_KEY = "state"
 
-    WORKSPACE_BASE = {root}/automation-runs/{run_id}
-    State lives two levels up at {root}/automation-state/.
-    """
+
+def _kv_available() -> bool:
+    return bool(_KV_TOKEN and _KV_BASE)
+
+
+def _kv_get(key: str) -> dict | None:
+    req = urllib.request.Request(
+        f"{_KV_BASE}/v1/kv/{key}",
+        headers={"Authorization": f"Bearer {_KV_TOKEN}"},
+    )
+    try:
+        with urllib.request.urlopen(req) as r:
+            return json.loads(r.read())["value"]
+    except urllib.error.HTTPError as exc:
+        if exc.code == 404:
+            return None
+        raise
+
+
+def _kv_set(key: str, value: dict) -> None:
+    req = urllib.request.Request(
+        f"{_KV_BASE}/v1/kv/{key}",
+        data=json.dumps(value).encode(),
+        headers={
+            "Authorization": f"Bearer {_KV_TOKEN}",
+            "Content-Type": "application/json",
+        },
+        method="PUT",
+    )
+    with urllib.request.urlopen(req) as r:
+        r.read()
+
+
+def _state_file_path() -> str:
+    """Derive a persistent storage path from WORKSPACE_BASE (file fallback only)."""
     workspace_base = os.environ.get("WORKSPACE_BASE", "")
     event_payload = json.loads(os.environ.get("AUTOMATION_EVENT_PAYLOAD", "{}"))
     automation_id = event_payload.get("automation_id", "default")
@@ -220,22 +252,42 @@ def _state_file_path() -> str:
     return os.path.join(state_dir, f"slack_poller_{automation_id}.json")
 
 
-def load_state(path: str) -> dict:
-    if os.path.exists(path):
-        return json.load(open(path))
+def _default_state() -> dict:
     return {
         "version": 1,
         "bot_user_id": None,
-        "last_poll": {},           # channel_id → float timestamp string
-        "conversations": {},       # conv_key → ConversationRecord (see schema docs)
-        "bot_message_ts": [],      # ts strings of messages posted by this bot
-        "processed_ts": [],        # ts strings of messages already handled (dedup)
+        "last_poll": {},
+        "conversations": {},
+        "bot_message_ts": [],
+        "processed_ts": [],
     }
 
 
-def save_state(path: str, state: dict) -> None:
+def load_state() -> dict:
+    if _kv_available():
+        data = _kv_get(_STATE_KEY)
+        if data is not None:
+            print("State loaded from KV store")
+            return data
+        return _default_state()
+    path = _state_file_path()
+    if os.path.exists(path):
+        try:
+            return json.load(open(path))
+        except Exception as exc:
+            print(f"Warning: state file {path} unreadable ({exc}); starting fresh")
+    return _default_state()
+
+
+def save_state(state: dict) -> None:
+    if _kv_available():
+        _kv_set(_STATE_KEY, state)
+        print("State saved to KV store")
+        return
+    path = _state_file_path()
     with open(path, "w") as f:
         json.dump(state, f, indent=2)
+    print(f"State saved to {path}")
 
 
 # ── Slack API helpers ──────────────────────────────────────────────────────────
@@ -311,7 +363,12 @@ def add_reaction(token: str, channel: str, ts: str, emoji: str = "eyes") -> None
 
 def post_message(token: str, channel: str, text: str, thread_ts: str | None = None) -> str:
     """Post a Slack message and return its timestamp."""
-    body: dict = {"channel": channel, "text": text}
+    body: dict = {
+        "channel": channel,
+        "markdown_text": text,
+        "unfurl_links": False,
+        "unfurl_media": False,
+    }
     if thread_ts:
         body["thread_ts"] = thread_ts
     return slack_post(token, "chat.postMessage", body).get("ts", "")
@@ -665,16 +722,19 @@ def _gather_channel_context(
     return context_lines
 
 
-def _expire_inactive_thread_watches(active_convs: dict[str, dict], now: float) -> None:
-    for conv_key, rec in active_convs.items():
-        if rec.get("status") != "watching":
-            continue
-        watch_until = float(rec.get("watch_until") or 0)
-        if watch_until and now >= watch_until:
-            rec["status"] = "closed"
-            rec["closed_reason"] = "followup_watch_expired"
-            rec["closed_at"] = now
-            print(f"  Follow-up watch expired for {conv_key}")
+def _close_thread_watch(rec: dict, conv_key: str, now: float) -> None:
+    rec["status"] = "closed"
+    rec["closed_reason"] = "followup_watch_expired"
+    rec["closed_at"] = now
+    print(f"  Follow-up watch expired for {conv_key}")
+
+
+def _next_reply_poll_at(rec: dict, now: float, delay: int) -> float:
+    next_poll_at = now + delay
+    watch_until = float(rec.get("watch_until") or 0)
+    if rec.get("status") == "watching" and watch_until:
+        next_poll_at = min(next_poll_at, watch_until)
+    return next_poll_at
 
 
 def _poll_due_thread_replies(
@@ -684,12 +744,14 @@ def _poll_due_thread_replies(
     bot_message_ts: list[str],
 ) -> list[tuple[str, dict]]:
     now = time.time()
-    _expire_inactive_thread_watches(active_convs, now)
     due: list[tuple[float, str, dict]] = []
     for conv_key, rec in active_convs.items():
         if rec.get("status") not in {"active", "watching"}:
             continue
         next_poll = float(rec.get("next_reply_poll_at") or 0)
+        watch_until = float(rec.get("watch_until") or 0)
+        if rec.get("status") == "watching" and watch_until and now >= watch_until:
+            next_poll = min(next_poll or watch_until, watch_until)
         if next_poll <= now:
             due.append((next_poll, conv_key, rec))
 
@@ -698,6 +760,8 @@ def _poll_due_thread_replies(
         cid = rec["channel_id"]
         thread_ts = rec["thread_ts"]
         oldest = rec.get("last_seen_reply_ts") or thread_ts
+        watch_until = float(rec.get("watch_until") or 0)
+        watch_expired = rec.get("status") == "watching" and watch_until and now >= watch_until
         try:
             replies = thread_replies(slack_token, cid, thread_ts, oldest)
         except Exception as exc:
@@ -710,11 +774,14 @@ def _poll_due_thread_replies(
                     retry_after = max(THREAD_REPLY_INITIAL_BACKOFF_SECONDS, int(raw))
                 except ValueError:
                     pass
-            rec["next_reply_poll_at"] = now + retry_after
-            rec["reply_poll_backoff_seconds"] = min(
-                THREAD_REPLY_MAX_BACKOFF_SECONDS,
-                max(retry_after, int(rec.get("reply_poll_backoff_seconds") or THREAD_REPLY_INITIAL_BACKOFF_SECONDS)),
-            )
+            if watch_expired:
+                _close_thread_watch(rec, conv_key, now)
+            else:
+                rec["next_reply_poll_at"] = _next_reply_poll_at(rec, now, retry_after)
+                rec["reply_poll_backoff_seconds"] = min(
+                    THREAD_REPLY_MAX_BACKOFF_SECONDS,
+                    max(retry_after, int(rec.get("reply_poll_backoff_seconds") or THREAD_REPLY_INITIAL_BACKOFF_SECONDS)),
+                )
             print(f"  Warning: could not fetch replies for thread {thread_ts}: {exc}")
             continue
 
@@ -733,6 +800,10 @@ def _poll_due_thread_replies(
             for r in triggered_replies:
                 reply_messages.append((cid, r))
             print(f"  {conv_key}: {len(triggered_replies)} triggered follow-up reply/replies")
+        elif watch_expired:
+            if human_replies:
+                print(f"  {conv_key}: ignored {len(human_replies)} follow-up reply/replies without trigger")
+            _close_thread_watch(rec, conv_key, now)
         else:
             if human_replies:
                 print(f"  {conv_key}: ignored {len(human_replies)} follow-up reply/replies without trigger")
@@ -742,8 +813,9 @@ def _poll_due_thread_replies(
                 max(THREAD_REPLY_INITIAL_BACKOFF_SECONDS, current * THREAD_REPLY_BACKOFF_MULTIPLIER),
             )
             rec["reply_poll_backoff_seconds"] = next_backoff
-            rec["next_reply_poll_at"] = now + next_backoff
-            print(f"  {conv_key}: no follow-ups; next reply poll in {next_backoff}s")
+            rec["next_reply_poll_at"] = _next_reply_poll_at(rec, now, next_backoff)
+            next_delay = max(0, int(rec["next_reply_poll_at"] - now))
+            print(f"  {conv_key}: no follow-ups; next reply poll in {next_delay}s")
 
     return reply_messages
 
@@ -951,8 +1023,7 @@ def _check_conversation_completion(
 
 def main() -> str | None:
     """Run one polling cycle. Returns the last conversation ID created, if any."""
-    state_path = _state_file_path()
-    state = load_state(state_path)
+    state = load_state()
 
     agent_url = os.environ.get("AGENT_SERVER_URL", "").rstrip("/")
     api_key = _get_env_key()
@@ -1139,8 +1210,7 @@ def main() -> str | None:
     state["processed_ts"] = processed_list[-MAX_PROCESSED_TS:]
 
     state["conversations"] = active_convs
-    save_state(state_path, state)
-    print(f"State saved to {state_path}")
+    save_state(state)
     return last_conversation_id
 
 

package/tests/test_catalog_schema.py

@@ -0,0 +1,47 @@
+"""Strict JSON-Schema validation for integrations/catalog/*.json.
+
+Every catalog entry must validate against integrations/catalog.schema.json.
+The schema encodes the catalog contract from integrations/index.d.ts plus the
+cross-field connectability rules (e.g. an oauth2 HTTP option must carry an
+authorizationUrl + tokenUrl; an HTTP option must ship an openApiUrl) so the
+class of "entry looks shaped but cannot actually be connected" regressions the
+AI reviewer kept catching is now caught in CI.
+"""
+
+import json
+from pathlib import Path
+
+import pytest
+from jsonschema import Draft202012Validator
+
+ROOT = Path(__file__).resolve().parents[1]
+SCHEMA_PATH = ROOT / "integrations" / "catalog.schema.json"
+CATALOG_DIR = ROOT / "integrations" / "catalog"
+
+_SCHEMA = json.loads(SCHEMA_PATH.read_text())
+VALIDATOR = Draft202012Validator(_SCHEMA)
+
+
+def _catalog_entries():
+    for entry_path in sorted(CATALOG_DIR.glob("*.json")):
+        yield pytest.param(
+            entry_path,
+            id=entry_path.stem,
+        )
+
+
+@pytest.mark.parametrize("entry_path", list(_catalog_entries()))
+def test_catalog_entry_validates_against_schema(entry_path: Path) -> None:
+    entry = json.loads(entry_path.read_text())
+    errors = sorted(VALIDATOR.iter_errors(entry), key=lambda e: list(e.path))
+    if errors:
+        rendered = "\n".join(
+            f"  - at {'/'.join(map(str, e.path)) or '<root>'}: {e.message}"
+            for e in errors
+        )
+        pytest.fail(f"{entry_path.stem} failed schema validation:\n{rendered}")
+
+
+def test_schema_file_is_valid_draft_2020_12() -> None:
+    """The schema itself must be a valid Draft 2020-12 document."""
+    Draft202012Validator.check_schema(_SCHEMA)

package/tests/test_catalogs.py

@@ -40,10 +40,10 @@ def test_catalog_entries_have_required_fields():
         assert entry["id"]
         assert entry["name"]
         assert entry["description"]
-        assert entry["kind"] in {"mcp", "http"}
-        assert entry["iconBg"]
+        # iconBg/iconColor are optional UI styling hints (OAuth-only entries may
+        # ship without a bespoke icon background).
+        assert "iconBg" not in entry or entry["iconBg"]
         assert entry["connectionOptions"]
-        assert entry["defaultConnectionOptionId"]
         for option in entry["connectionOptions"]:
             assert option["id"]
             assert option["provider"] in {"mcp", "http"}
@@ -72,6 +72,24 @@ def test_catalog_entries_have_required_fields():
         assert isinstance(entry["estimatedSetupMinutes"], int)
 
 
+def test_remote_no_auth_mcp_entries_are_intentionally_public():
+    public_remote_mcp_ids = {"cloudflare-docs", "deepwiki", "huggingface"}
+
+    actual = set()
+    for entry in load_catalog_entries("integrations/catalog"):
+        for option in entry["connectionOptions"]:
+            transport = option.get("transport", {})
+            if (
+                option["provider"] == "mcp"
+                and option["auth"]["strategy"] == "none"
+                and transport.get("url", "").startswith("https://")
+            ):
+                actual.add(entry["id"])
+                assert transport["kind"] == "shttp"
+
+    assert actual == public_remote_mcp_ids
+
+
 def test_credential_fields_have_helper_text_and_link():
     """All password fields must have helperText plus a link (either a helperLink field or a
     markdown link embedded in helperText) so users know how to get credentials."""
@@ -107,3 +125,29 @@ def test_node_package_exports_catalogs():
       if (!AUTOMATION_CATALOG.some((entry) => entry.id === 'github-pr-reviewer')) process.exit(1);
     """
     subprocess.run(["node", "--input-type=module", "-e", script], cwd=ROOT, check=True)
+
+
+def test_no_default_tool_in_catalog():
+    """The defaultTool field was removed; tools now come from MCP tools/list or
+    HTTP OpenAPI regeneration. No connection option may carry it."""
+    offenders = []
+    for entry in load_catalog_entries("integrations/catalog"):
+        for option in entry["connectionOptions"]:
+            http_cfg = option.get("http", {})
+            if "defaultTool" in http_cfg:
+                offenders.append(f"{entry['id']}.{option['id']}")
+    assert not offenders, f"defaultTool still present in: {offenders}"
+
+
+def test_http_connectors_have_openapi_url():
+    """An HTTP connector without an openApiUrl has no tool-discovery path once
+    defaultTool is gone, so every HTTP option must ship an openApiUrl."""
+    offenders = []
+    for entry in load_catalog_entries("integrations/catalog"):
+        for option in entry["connectionOptions"]:
+            if option["provider"] == "http":
+                http_cfg = option.get("http", {})
+                url = http_cfg.get("openApiUrl")
+                if not url or not url.startswith("https://"):
+                    offenders.append(f"{entry['id']}.{option['id']}")
+    assert not offenders, f"HTTP options missing openApiUrl: {offenders}"

package/tests/test_integration_catalog_in_sync.py

@@ -0,0 +1,252 @@
+"""Assert integration catalog files drive the generated JS/Python assets."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import openhands_extensions
+
+ROOT = Path(__file__).resolve().parents[1]
+CATALOG_DIR = ROOT / "integrations" / "catalog"
+CATALOG_INDEX = ROOT / "integrations" / "catalog-index.js"
+AGGREGATE_ASSETS = [
+    ROOT / "integrations" / "integration-catalog.json",
+    ROOT / "python" / "openhands_extensions" / "integration-catalog.json",
+]
+
+
+def _catalog_files() -> dict[str, dict]:
+    return {p.stem: json.loads(p.read_text()) for p in CATALOG_DIR.glob("*.json")}
+
+
+def _catalog_entries() -> list[dict]:
+    entries = list(_catalog_files().values())
+    return sorted(entries, key=lambda entry: (-(entry.get("popularityRank") if entry.get("popularityRank") is not None else -1), entry["id"]))
+
+
+def _supports_mcp(entry: dict) -> bool:
+    return any(option.get("provider") == "mcp" for option in entry["connectionOptions"])
+
+
+def _supports_oauth(entry: dict) -> bool:
+    return any(option.get("auth", {}).get("strategy") == "oauth2" for option in entry["connectionOptions"])
+
+
+
+def test_catalog_directory_is_hand_authored_source_of_truth() -> None:
+    for integration_id, entry in _catalog_files().items():
+        assert entry["id"] == integration_id
+        assert "supportsMcp" not in entry
+        assert "supportsOauth" not in entry
+        assert "oauthProvider" not in entry
+        assert "registrationDefaults" not in entry
+        assert "managedConnectorSlug" not in entry
+        assert "authStrategy" not in entry
+        assert "defaultConnectionOptionId" not in entry
+        assert "kind" not in entry
+        assert "catalogStatus" not in entry
+        assert "availability" not in entry
+        assert "runtimeAvailability" not in entry
+
+
+def test_no_aggregate_catalog_json_exists() -> None:
+    for asset in AGGREGATE_ASSETS:
+        assert not asset.exists()
+
+
+def test_generated_js_index_references_catalog_directory() -> None:
+    body = CATALOG_INDEX.read_text()
+    for file in sorted(path.name for path in CATALOG_DIR.glob("*.json")):
+        assert f"./catalog/{file}" in body
+    assert "integration-catalog.json" not in body
+
+
+def test_python_snapshot_is_built_from_catalog_directory() -> None:
+    assert openhands_extensions.INTEGRATION_CATALOG_SNAPSHOT == {
+        "integrations": _catalog_entries()
+    }
+
+
+def test_python_list_integration_catalog_returns_raw_entries() -> None:
+    entries = openhands_extensions.list_integration_catalog()
+    assert entries == _catalog_entries()
+    for entry in entries:
+        assert "supportsMcp" not in entry
+        assert "supportsOauth" not in entry
+        assert "registrationDefaults" not in entry
+        assert "managedConnectorSlug" not in entry
+        assert "authStrategy" not in entry
+        assert "defaultConnectionOptionId" not in entry
+        assert "catalogStatus" not in entry
+        assert "availability" not in entry
+        assert "runtimeAvailability" not in entry
+
+
+def test_logo_metadata_is_serializable_and_language_agnostic() -> None:
+    entries = openhands_extensions.list_integration_catalog()
+    with_logo = [entry for entry in entries if entry.get("logoUrl")]
+    assert with_logo
+    assert any(entry["id"].startswith("cloudflare-") for entry in with_logo)
+    for entry in with_logo:
+        assert isinstance(entry["logoUrl"], str)
+        assert entry["logoUrl"].startswith("https://")
+        assert "react" not in entry["logoUrl"].lower()
+
+
+def test_get_integration_catalog_entry_round_trip() -> None:
+    sample_id = openhands_extensions.list_integration_catalog()[0]["id"]
+    sample = openhands_extensions.get_integration_catalog_entry(sample_id)
+    assert sample is not None
+    assert sample == next(
+        entry
+        for entry in openhands_extensions.list_integration_catalog()
+        if entry["id"] == sample_id
+    )
+    assert openhands_extensions.get_integration_catalog_entry("nope") is None
+
+
+def _js_call(expr: str) -> str:
+    result = subprocess.run(
+        ["node", "--input-type=module", "-e", expr],
+        capture_output=True,
+        text=True,
+        check=True,
+        cwd=ROOT,
+    )
+    return result.stdout
+
+
+def test_js_reads_the_same_catalog_as_python() -> None:
+    integrations = _js_call(
+        "import { listIntegrationCatalog } from './integrations/index.js';\n"
+        "process.stdout.write(JSON.stringify(listIntegrationCatalog()));"
+    )
+    assert json.loads(integrations) == openhands_extensions.list_integration_catalog()
+
+    sample_id = openhands_extensions.list_integration_catalog()[0]["id"]
+    sample = _js_call(
+        "import { getIntegrationCatalogEntry } from './integrations/index.js';\n"
+        f"process.stdout.write(JSON.stringify(getIntegrationCatalogEntry({json.dumps(sample_id)})));"
+    )
+    assert json.loads(sample) == openhands_extensions.get_integration_catalog_entry(sample_id)
+
+
+def _js_filter(mcp, oauth) -> list[str]:
+    expr = (
+        "import { listIntegrationCatalog } from './integrations/index.js';\n"
+        f"const f = listIntegrationCatalog({{ mcp: {mcp}, oauth: {oauth} }});\n"
+        "process.stdout.write(JSON.stringify(f.map((e) => e.id)));"
+    )
+    return json.loads(_js_call(expr))
+
+
+def test_filter_mcp_only() -> None:
+    py_ids = {e["id"] for e in openhands_extensions.list_integration_catalog(mcp=True)}
+    js_ids = set(_js_filter("true", "undefined"))
+    all_mcp = {
+        e["id"]
+        for e in openhands_extensions.list_integration_catalog()
+        if _supports_mcp(e)
+    }
+    assert py_ids == js_ids == all_mcp
+    assert "filesystem" in py_ids
+
+
+def test_filter_oauth_only() -> None:
+    py_ids = {e["id"] for e in openhands_extensions.list_integration_catalog(oauth=True)}
+    js_ids = set(_js_filter("undefined", "true"))
+    all_oauth = {
+        e["id"]
+        for e in openhands_extensions.list_integration_catalog()
+        if _supports_oauth(e)
+    }
+    assert py_ids == js_ids == all_oauth
+    assert py_ids
+
+
+def test_filter_oauth_not_mcp() -> None:
+    py_ids = {
+        e["id"] for e in openhands_extensions.list_integration_catalog(oauth=True, mcp=False)
+    }
+    js_ids = set(_js_filter("false", "true"))
+    expected = {
+        e["id"]
+        for e in openhands_extensions.list_integration_catalog()
+        if _supports_oauth(e) and not _supports_mcp(e)
+    }
+    assert py_ids == js_ids == expected
+
+
+def test_filter_none_returns_all() -> None:
+    assert len(openhands_extensions.list_integration_catalog()) == len(
+        openhands_extensions.list_integration_catalog(mcp=None, oauth=None)
+    )
+
+
+def test_accessors_return_independent_copies() -> None:
+    catalog_a = openhands_extensions.list_integration_catalog()
+    catalog_b = openhands_extensions.list_integration_catalog()
+    assert catalog_a == catalog_b
+    assert catalog_a is not catalog_b
+    catalog_a[0]["__mutated"] = True
+    assert "__mutated" not in openhands_extensions.list_integration_catalog()[0]
+
+    sample_id = openhands_extensions.list_integration_catalog()[0]["id"]
+    sample = openhands_extensions.get_integration_catalog_entry(sample_id)
+    assert sample is not None
+    sample["__mutated"] = True
+    assert "__mutated" not in openhands_extensions.get_integration_catalog_entry(sample_id)
+
+    snapshot = openhands_extensions.INTEGRATION_CATALOG_SNAPSHOT
+    snapshot["integrations"][0]["__mutated"] = True
+    assert "__mutated" not in openhands_extensions.list_integration_catalog()[0]
+
+
+def test_js_accessors_return_independent_copies() -> None:
+    sample_id = openhands_extensions.list_integration_catalog()[0]["id"]
+    expr = f"""
+        import {{
+          INTEGRATION_CATALOG,
+          getIntegrationCatalogEntry,
+          listIntegrationCatalog,
+        }} from './integrations/index.js';
+        const sampleId = {json.dumps(sample_id)};
+        const first = listIntegrationCatalog();
+        const second = listIntegrationCatalog();
+        first[0].__mutated = true;
+        const entry = getIntegrationCatalogEntry(sampleId);
+        entry.__mutated = true;
+        INTEGRATION_CATALOG[0].__mutated = true;
+        process.stdout.write(JSON.stringify({{
+          listsAreIndependent:
+            !('__mutated' in second[0]) &&
+            !('__mutated' in listIntegrationCatalog()[0]),
+          entryIsIndependent: !('__mutated' in getIntegrationCatalogEntry(sampleId)),
+        }}));
+    """
+    result = json.loads(_js_call(expr))
+    assert result == {"listsAreIndependent": True, "entryIsIndependent": True}
+
+
+def test_oauth_config_lives_on_connection_options() -> None:
+    oauth_entries = [
+        entry
+        for entry in openhands_extensions.list_integration_catalog()
+        if _supports_oauth(entry)
+    ]
+    assert oauth_entries
+    for entry in oauth_entries:
+        assert "registrationDefaults" not in entry
+        oauth_options = [
+            option
+            for option in entry["connectionOptions"]
+            if option.get("auth", {}).get("strategy") == "oauth2"
+        ]
+        assert oauth_options
+        for option in oauth_options:
+            assert "registrationDefaults" not in option
+            oauth = option["auth"].get("oauth")
+            if oauth is not None:
+                assert isinstance(oauth, dict)