airbyte-internal-ops 0.10.0__tar.gz → 0.10.1__tar.gz

{airbyte_internal_ops-0.10.0 → airbyte_internal_ops-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-internal-ops
-Version: 0.10.0
+Version: 0.10.1
 Summary: MCP and API interfaces that let the agents do the admin work
 Author-email: Aaron Steers <aj@airbyte.io>
 Keywords: admin,airbyte,api,mcp

{airbyte_internal_ops-0.10.0 → airbyte_internal_ops-0.10.1}/src/airbyte_ops_mcp/cloud_admin/api_client.py

@@ -1768,3 +1768,73 @@ def finalize_connector_rollout(
         )
 
     return response.json()
+
+
+def get_actor_sync_info(
+    rollout_id: str,
+    config_api_root: str,
+    client_id: str | None = None,
+    client_secret: str | None = None,
+    bearer_token: str | None = None,
+) -> dict[str, Any]:
+    """Get actor sync info for a connector rollout.
+
+    This function calls the platform API to get sync statistics for actors
+    participating in a rollout. Unlike the SQL-based approach, this endpoint
+    filters sync stats to only include syncs that actually used the RC version
+    associated with the rollout.
+
+    Args:
+        rollout_id: The rollout ID (UUID)
+        config_api_root: The Config API root URL (e.g., CLOUD_CONFIG_API_ROOT)
+        client_id: The Airbyte Cloud client ID (required if no bearer_token)
+        client_secret: The Airbyte Cloud client secret (required if no bearer_token)
+        bearer_token: Pre-existing bearer token (takes precedence over client credentials)
+
+    Returns:
+        Dictionary containing:
+        - data.actorSelectionInfo: Info about actor selection (numActors, numPinnedToConnectorRollout, etc.)
+        - data.syncs: Dict mapping actor_id to sync stats (numConnections, numSucceeded, numFailed)
+
+    Raises:
+        PyAirbyteInputError: If the API request fails or rollout not found
+    """
+    access_token = _get_access_token(client_id, client_secret, bearer_token)
+
+    endpoint = f"{config_api_root}/connector_rollout/get_actor_sync_info"
+    payload = {"id": rollout_id}
+
+    response = requests.post(
+        endpoint,
+        json=payload,
+        headers={
+            "Authorization": f"Bearer {access_token}",
+            "User-Agent": ops_constants.USER_AGENT,
+            "Content-Type": "application/json",
+        },
+        timeout=60,
+    )
+
+    if response.status_code == 404:
+        raise PyAirbyteInputError(
+            message=f"Rollout not found: {rollout_id}",
+            context={
+                "rollout_id": rollout_id,
+                "endpoint": endpoint,
+                "status_code": response.status_code,
+                "response": response.text,
+            },
+        )
+
+    if response.status_code != 200:
+        raise PyAirbyteInputError(
+            message=f"Failed to get actor sync info: {response.status_code} {response.text}",
+            context={
+                "rollout_id": rollout_id,
+                "endpoint": endpoint,
+                "status_code": response.status_code,
+                "response": response.text,
+            },
+        )
+
+    return response.json()

{airbyte_internal_ops-0.10.0 → airbyte_internal_ops-0.10.1}/src/airbyte_ops_mcp/mcp/connector_rollout.py

@@ -17,7 +17,7 @@ from airbyte import constants
 from airbyte.exceptions import PyAirbyteInputError
 from fastmcp import Context, FastMCP
 from fastmcp_extensions import get_mcp_config, mcp_tool, register_mcp_tools
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 from airbyte_ops_mcp.cloud_admin import api_client
 from airbyte_ops_mcp.cloud_admin.auth import (
@@ -770,6 +770,109 @@ def finalize_connector_rollout(
         )
 
 
+class RolloutActorSelectionInfo(BaseModel):
+    """Actor selection info for a connector rollout."""
+
+    num_actors: int = Field(description="Total actors using this connector")
+    num_pinned_to_connector_rollout: int = Field(
+        description="Actors specifically pinned to this rollout"
+    )
+    num_actors_eligible_or_already_pinned: int = Field(
+        description="Actors eligible for pinning or already pinned"
+    )
+
+
+class RolloutActorSyncStats(BaseModel):
+    """Per-actor sync stats for a rollout (only syncs using the RC version)."""
+
+    actor_id: str = Field(description="Actor UUID")
+    num_connections: int = Field(description="Number of connections using this actor")
+    num_succeeded: int = Field(
+        description="Number of successful syncs using the RC version"
+    )
+    num_failed: int = Field(description="Number of failed syncs using the RC version")
+
+
+class RolloutMonitoringResult(BaseModel):
+    """Complete monitoring result for a rollout from the platform API.
+
+    This uses the platform API's /get_actor_sync_info endpoint which filters
+    sync stats to only include syncs that actually used the RC version
+    associated with the rollout.
+    """
+
+    rollout_id: str = Field(description="Rollout UUID")
+    actor_selection_info: RolloutActorSelectionInfo = Field(
+        description="Actor selection info for the rollout"
+    )
+    actor_sync_stats: list[RolloutActorSyncStats] = Field(
+        description="Per-actor sync stats for actors pinned to the rollout"
+    )
+
+
+@mcp_tool(
+    read_only=True,
+    idempotent=True,
+)
+def query_prod_rollout_monitoring_stats(
+    rollout_id: Annotated[
+        str,
+        Field(description="Rollout UUID to get monitoring stats for"),
+    ],
+    *,
+    ctx: Context,
+) -> RolloutMonitoringResult:
+    """Get monitoring stats for a connector rollout.
+
+    Returns actor selection info and per-actor sync stats for actors
+    participating in the rollout. This uses the platform API's
+    /get_actor_sync_info endpoint which filters sync stats to only include
+    syncs that actually used the RC version associated with the rollout.
+
+    This is more accurate than SQL-based approaches which count all syncs
+    regardless of which connector version was used.
+    """
+    auth = _resolve_cloud_auth(ctx)
+
+    response = api_client.get_actor_sync_info(
+        rollout_id=rollout_id,
+        config_api_root=constants.CLOUD_CONFIG_API_ROOT,
+        client_id=auth.client_id,
+        client_secret=auth.client_secret,
+        bearer_token=auth.bearer_token,
+    )
+
+    data = response.get("data", {})
+    actor_selection_info_data = data.get("actorSelectionInfo", {})
+    syncs_data = data.get("syncs", {})
+
+    actor_selection_info = RolloutActorSelectionInfo(
+        num_actors=actor_selection_info_data.get("numActors", 0),
+        num_pinned_to_connector_rollout=actor_selection_info_data.get(
+            "numPinnedToConnectorRollout", 0
+        ),
+        num_actors_eligible_or_already_pinned=actor_selection_info_data.get(
+            "numActorsEligibleOrAlreadyPinned", 0
+        ),
+    )
+
+    actor_sync_stats = [
+        RolloutActorSyncStats(
+            actor_id=actor_id,
+            num_connections=sync_info.get("numConnections", 0),
+            num_succeeded=sync_info.get("numSucceeded", 0),
+            num_failed=sync_info.get("numFailed", 0),
+        )
+        for actor_id, sync_info in syncs_data.items()
+    ]
+
+    return RolloutMonitoringResult(
+        rollout_id=rollout_id,
+        actor_selection_info=actor_selection_info,
+        actor_sync_stats=actor_sync_stats,
+    )
+
+
 def register_connector_rollout_tools(app: FastMCP) -> None:
     """Register connector rollout tools with the FastMCP app.
 

{airbyte_internal_ops-0.10.0 → airbyte_internal_ops-0.10.1}/src/airbyte_ops_mcp/mcp/prod_db_queries.py

@@ -1412,93 +1412,6 @@ def query_prod_connector_rollouts(
     return [_row_to_connector_rollout_info(row) for row in rows]
 
 
-class RolloutMonitoringStats(BaseModel):
-    """Aggregate monitoring stats for a connector rollout."""
-
-    rollout_id: str = Field(description="Rollout UUID")
-    actor_definition_id: str = Field(description="Connector definition UUID")
-    num_actors: int = Field(description="Total actors using this connector")
-    num_actors_pinned: int = Field(
-        description="Actors with any version pin (eligible or already pinned)"
-    )
-    num_pinned_to_rollout: int = Field(
-        description="Actors specifically pinned to this rollout"
-    )
-
-
-class RolloutActorSyncStats(BaseModel):
-    """Per-actor sync stats for a rollout."""
-
-    actor_id: str = Field(description="Actor UUID")
-    num_succeeded: int = Field(description="Number of successful syncs")
-    num_failed: int = Field(description="Number of failed syncs")
-    num_connections: int = Field(description="Number of connections using this actor")
-
-
-class RolloutMonitoringResult(BaseModel):
-    """Complete monitoring result for a rollout."""
-
-    aggregate_stats: RolloutMonitoringStats = Field(
-        description="Aggregate counts for the rollout"
-    )
-    actor_stats: list[RolloutActorSyncStats] = Field(
-        description="Per-actor sync stats for actors pinned to the rollout"
-    )
-
-
-@mcp_tool(
-    read_only=True,
-    idempotent=True,
-)
-def query_prod_rollout_monitoring_stats(
-    rollout_id: Annotated[
-        str,
-        Field(description="Rollout UUID to get monitoring stats for"),
-    ],
-    days_back: Annotated[
-        int,
-        Field(description="Number of days to look back for sync stats (default: 7)"),
-    ] = 7,
-) -> RolloutMonitoringResult:
-    """Get monitoring stats for a connector rollout.
-
-    Returns aggregate counts (total actors, pinned actors, rollout-pinned actors)
-    and per-actor sync stats (succeeded, failed, connections) for actors
-    participating in the rollout. This replaces the Retool rollout monitoring UI.
-    """
-    from airbyte_ops_mcp.prod_db_access.queries import (
-        query_rollout_actor_sync_stats,
-        query_rollout_monitoring_stats,
-    )
-
-    agg_stats = query_rollout_monitoring_stats(rollout_id=rollout_id)
-    if agg_stats is None:
-        raise ValueError(f"Rollout not found: {rollout_id}")
-
-    actor_stats = query_rollout_actor_sync_stats(
-        rollout_id=rollout_id, days_back=days_back
-    )
-
-    return RolloutMonitoringResult(
-        aggregate_stats=RolloutMonitoringStats(
-            rollout_id=str(agg_stats["rollout_id"]),
-            actor_definition_id=str(agg_stats["actor_definition_id"]),
-            num_actors=agg_stats["num_actors"] or 0,
-            num_actors_pinned=agg_stats["num_actors_pinned"] or 0,
-            num_pinned_to_rollout=agg_stats["num_pinned_to_rollout"] or 0,
-        ),
-        actor_stats=[
-            RolloutActorSyncStats(
-                actor_id=str(row["actor_id"]),
-                num_succeeded=row["num_succeeded"] or 0,
-                num_failed=row["num_failed"] or 0,
-                num_connections=row["num_connections"] or 0,
-            )
-            for row in actor_stats
-        ],
-    )
-
-
 def register_prod_db_query_tools(app: FastMCP) -> None:
     """Register prod DB query tools with the FastMCP app."""
     register_mcp_tools(app, mcp_module=__name__)

{airbyte_internal_ops-0.10.0 → airbyte_internal_ops-0.10.1}/src/airbyte_ops_mcp/prod_db_access/queries.py

@@ -42,8 +42,6 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_SOURCE_CONNECTOR,
     SELECT_RECENT_SYNCS_FOR_DESTINATION_CONNECTOR,
     SELECT_RECENT_SYNCS_FOR_SOURCE_CONNECTOR,
-    SELECT_ROLLOUT_ACTOR_SYNC_STATS,
-    SELECT_ROLLOUT_AGGREGATE_STATS,
     SELECT_SOURCE_CONNECTION_STATS,
     SELECT_SUCCESSFUL_SYNCS_FOR_VERSION,
     SELECT_SYNC_RESULTS_FOR_VERSION,
@@ -701,62 +699,3 @@ def query_connector_rollouts(
         query_name="SELECT_ACTIVE_CONNECTOR_ROLLOUTS",
         gsm_client=gsm_client,
     )
-
-
-def query_rollout_monitoring_stats(
-    rollout_id: str,
-    *,
-    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
-) -> dict[str, Any] | None:
-    """Query aggregate monitoring stats for a rollout.
-
-    Returns counts of total actors, actors with any pin, and actors pinned
-    specifically to this rollout.
-
-    Args:
-        rollout_id: Rollout UUID to get stats for
-        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
-
-    Returns:
-        Dict with rollout_id, actor_definition_id, num_actors, num_actors_pinned,
-        num_pinned_to_rollout, or None if rollout not found
-    """
-    rows = _run_sql_query(
-        SELECT_ROLLOUT_AGGREGATE_STATS,
-        parameters={"rollout_id": rollout_id},
-        query_name="SELECT_ROLLOUT_AGGREGATE_STATS",
-        gsm_client=gsm_client,
-    )
-    # The SQL query uses scalar subqueries that always return one row,
-    # but with NULL values if the rollout doesn't exist
-    if rows and rows[0].get("rollout_id") is not None:
-        return rows[0]
-    return None
-
-
-def query_rollout_actor_sync_stats(
-    rollout_id: str,
-    days_back: int = 7,
-    *,
-    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
-) -> list[dict[str, Any]]:
-    """Query per-actor sync stats for actors pinned to a rollout.
-
-    Returns succeeded/failed job counts and connection counts for each actor
-    that is pinned to the specified rollout.
-
-    Args:
-        rollout_id: Rollout UUID to get actor stats for
-        days_back: Number of days to look back for job stats (default: 7)
-        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
-
-    Returns:
-        List of dicts with actor_id, num_succeeded, num_failed, num_connections
-    """
-    cutoff_date = datetime.now(timezone.utc) - timedelta(days=days_back)
-    return _run_sql_query(
-        SELECT_ROLLOUT_ACTOR_SYNC_STATS,
-        parameters={"rollout_id": rollout_id, "cutoff_date": cutoff_date},
-        query_name="SELECT_ROLLOUT_ACTOR_SYNC_STATS",
-        gsm_client=gsm_client,
-    )

{airbyte_internal_ops-0.10.0 → airbyte_internal_ops-0.10.1}/src/airbyte_ops_mcp/prod_db_access/sql.py

@@ -1217,94 +1217,3 @@ SELECT_ACTORS_PINNED_TO_ROLLOUT = sqlalchemy.text(
          scoped_configuration.created_at DESC
     """
 )
-
-# Get rollout monitoring stats: aggregate counts for a rollout
-# Returns: total actors for connector, actors with any pin, actors pinned to this rollout
-SELECT_ROLLOUT_AGGREGATE_STATS = sqlalchemy.text(
-    """
-    WITH rollout_info AS (
-        SELECT
-            cr.id AS rollout_id,
-            cr.actor_definition_id,
-            cr.release_candidate_version_id
-        FROM connector_rollout cr
-        WHERE cr.id = :rollout_id
-    ),
-    total_actors AS (
-        SELECT COUNT(*) AS num_actors
-        FROM actor
-        WHERE actor.actor_definition_id = (SELECT actor_definition_id FROM rollout_info)
-          AND actor.tombstone = false
-    ),
-    pinned_actors AS (
-        SELECT COUNT(DISTINCT scoped_configuration.scope_id) AS num_pinned
-        FROM scoped_configuration
-        JOIN actor ON scoped_configuration.scope_id = actor.id
-        WHERE scoped_configuration.key = 'connector_version'
-          AND scoped_configuration.scope_type = 'actor'
-          AND actor.actor_definition_id = (SELECT actor_definition_id FROM rollout_info)
-          AND actor.tombstone = false
-    ),
-    rollout_pinned_actors AS (
-        SELECT COUNT(DISTINCT scoped_configuration.scope_id) AS num_rollout_pinned
-        FROM scoped_configuration
-        WHERE scoped_configuration.key = 'connector_version'
-          AND scoped_configuration.scope_type = 'actor'
-          AND scoped_configuration.origin = :rollout_id
-    )
-    SELECT
-        (SELECT rollout_id FROM rollout_info) AS rollout_id,
-        (SELECT actor_definition_id FROM rollout_info) AS actor_definition_id,
-        (SELECT num_actors FROM total_actors) AS num_actors,
-        (SELECT num_pinned FROM pinned_actors) AS num_actors_pinned,
-        (SELECT num_rollout_pinned FROM rollout_pinned_actors) AS num_pinned_to_rollout
-    """
-)
-
-# Get per-actor sync stats for actors pinned to a rollout
-# Returns: actor_id, succeeded count, failed count, connection count
-SELECT_ROLLOUT_ACTOR_SYNC_STATS = sqlalchemy.text(
-    """
-    WITH rollout_actors AS (
-        SELECT DISTINCT
-            scoped_configuration.scope_id AS actor_id
-        FROM scoped_configuration
-        WHERE scoped_configuration.key = 'connector_version'
-          AND scoped_configuration.scope_type = 'actor'
-          AND scoped_configuration.origin = :rollout_id
-    ),
-    actor_connections AS (
-        SELECT
-            ra.actor_id,
-            COUNT(DISTINCT c.id) AS num_connections
-        FROM rollout_actors ra
-        LEFT JOIN connection c
-          ON c.source_id = ra.actor_id OR c.destination_id = ra.actor_id
-        WHERE c.status != 'deprecated' OR c.status IS NULL
-        GROUP BY ra.actor_id
-    ),
-    actor_job_stats AS (
-        SELECT
-            ra.actor_id,
-            COUNT(CASE WHEN j.status = 'succeeded' THEN 1 END) AS num_succeeded,
-            COUNT(CASE WHEN j.status = 'failed' THEN 1 END) AS num_failed
-        FROM rollout_actors ra
-        LEFT JOIN connection c
-          ON c.source_id = ra.actor_id OR c.destination_id = ra.actor_id
-        LEFT JOIN jobs j
-          ON j.scope = c.id::text
-         AND j.config_type = 'sync'
-         AND j.created_at >= :cutoff_date
-        GROUP BY ra.actor_id
-    )
-    SELECT
-        ra.actor_id,
-        COALESCE(ajs.num_succeeded, 0) AS num_succeeded,
-        COALESCE(ajs.num_failed, 0) AS num_failed,
-        COALESCE(ac.num_connections, 0) AS num_connections
-    FROM rollout_actors ra
-    LEFT JOIN actor_job_stats ajs ON ra.actor_id = ajs.actor_id
-    LEFT JOIN actor_connections ac ON ra.actor_id = ac.actor_id
-    ORDER BY COALESCE(ajs.num_failed, 0) DESC, COALESCE(ajs.num_succeeded, 0) DESC
-    """
-)

airbyte_internal_ops-0.10.1/tests/test_connector_rollout_monitoring.py

@@ -0,0 +1,181 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+"""Unit tests for the connector rollout monitoring API-based tool."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from airbyte_ops_mcp.cloud_admin.api_client import get_actor_sync_info
+from airbyte_ops_mcp.mcp.connector_rollout import (
+    RolloutActorSelectionInfo,
+    RolloutActorSyncStats,
+    RolloutMonitoringResult,
+    query_prod_rollout_monitoring_stats,
+)
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize(
+    "api_response,expected_selection_info,expected_sync_stats",
+    [
+        pytest.param(
+            {
+                "data": {
+                    "actorSelectionInfo": {
+                        "numActors": 100,
+                        "numPinnedToConnectorRollout": 10,
+                        "numActorsEligibleOrAlreadyPinned": 50,
+                    },
+                    "syncs": {
+                        "actor-1": {
+                            "numConnections": 5,
+                            "numSucceeded": 10,
+                            "numFailed": 2,
+                        },
+                        "actor-2": {
+                            "numConnections": 3,
+                            "numSucceeded": 8,
+                            "numFailed": 0,
+                        },
+                    },
+                }
+            },
+            RolloutActorSelectionInfo(
+                num_actors=100,
+                num_pinned_to_connector_rollout=10,
+                num_actors_eligible_or_already_pinned=50,
+            ),
+            [
+                RolloutActorSyncStats(
+                    actor_id="actor-1",
+                    num_connections=5,
+                    num_succeeded=10,
+                    num_failed=2,
+                ),
+                RolloutActorSyncStats(
+                    actor_id="actor-2", num_connections=3, num_succeeded=8, num_failed=0
+                ),
+            ],
+            id="typical_response_with_multiple_actors",
+        ),
+        pytest.param(
+            {
+                "data": {
+                    "actorSelectionInfo": {
+                        "numActors": 0,
+                        "numPinnedToConnectorRollout": 0,
+                        "numActorsEligibleOrAlreadyPinned": 0,
+                    },
+                    "syncs": {},
+                }
+            },
+            RolloutActorSelectionInfo(
+                num_actors=0,
+                num_pinned_to_connector_rollout=0,
+                num_actors_eligible_or_already_pinned=0,
+            ),
+            [],
+            id="empty_rollout_no_actors",
+        ),
+        pytest.param(
+            {"data": {"actorSelectionInfo": {}, "syncs": {}}},
+            RolloutActorSelectionInfo(
+                num_actors=0,
+                num_pinned_to_connector_rollout=0,
+                num_actors_eligible_or_already_pinned=0,
+            ),
+            [],
+            id="missing_fields_defaults_to_zero",
+        ),
+    ],
+)
+def test_query_prod_rollout_monitoring_stats(
+    api_response: dict,
+    expected_selection_info: RolloutActorSelectionInfo,
+    expected_sync_stats: list[RolloutActorSyncStats],
+) -> None:
+    """Test query_prod_rollout_monitoring_stats transforms API response correctly."""
+    mock_ctx = MagicMock()
+    mock_ctx.request_context.lifespan_context = {}
+
+    with patch(
+        "airbyte_ops_mcp.mcp.connector_rollout._resolve_cloud_auth"
+    ) as mock_resolve_auth, patch(
+        "airbyte_ops_mcp.mcp.connector_rollout.api_client.get_actor_sync_info"
+    ) as mock_get_sync_info:
+        mock_resolve_auth.return_value = MagicMock(
+            bearer_token="test-token", client_id=None, client_secret=None
+        )
+        mock_get_sync_info.return_value = api_response
+
+        result = query_prod_rollout_monitoring_stats(
+            rollout_id="test-rollout-id", ctx=mock_ctx
+        )
+
+        assert isinstance(result, RolloutMonitoringResult)
+        assert result.rollout_id == "test-rollout-id"
+        assert result.actor_selection_info == expected_selection_info
+
+        assert len(result.actor_sync_stats) == len(expected_sync_stats)
+        for actual, expected in zip(
+            sorted(result.actor_sync_stats, key=lambda x: x.actor_id),
+            sorted(expected_sync_stats, key=lambda x: x.actor_id),
+        ):
+            assert actual == expected
+
+
+@pytest.mark.unit
+def test_get_actor_sync_info_api_call() -> None:
+    """Test get_actor_sync_info makes correct API call."""
+    with patch(
+        "airbyte_ops_mcp.cloud_admin.api_client._get_access_token"
+    ) as mock_get_token, patch(
+        "airbyte_ops_mcp.cloud_admin.api_client.requests.post"
+    ) as mock_post:
+        mock_get_token.return_value = "test-access-token"
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "data": {"actorSelectionInfo": {}, "syncs": {}}
+        }
+        mock_post.return_value = mock_response
+
+        result = get_actor_sync_info(
+            rollout_id="test-rollout-id",
+            config_api_root="https://api.test.com",
+            bearer_token="test-token",
+        )
+
+        mock_post.assert_called_once()
+        call_args = mock_post.call_args
+        assert (
+            call_args[0][0]
+            == "https://api.test.com/connector_rollout/get_actor_sync_info"
+        )
+        assert call_args[1]["json"] == {"id": "test-rollout-id"}
+        assert "Authorization" in call_args[1]["headers"]
+        assert result == {"data": {"actorSelectionInfo": {}, "syncs": {}}}
+
+
+@pytest.mark.unit
+def test_get_actor_sync_info_not_found() -> None:
+    """Test get_actor_sync_info raises error when rollout not found."""
+    from airbyte.exceptions import PyAirbyteInputError
+
+    with patch(
+        "airbyte_ops_mcp.cloud_admin.api_client._get_access_token"
+    ) as mock_get_token, patch(
+        "airbyte_ops_mcp.cloud_admin.api_client.requests.post"
+    ) as mock_post:
+        mock_get_token.return_value = "test-access-token"
+        mock_response = MagicMock()
+        mock_response.status_code = 404
+        mock_response.text = "Not found"
+        mock_post.return_value = mock_response
+
+        with pytest.raises(PyAirbyteInputError, match="Rollout not found"):
+            get_actor_sync_info(
+                rollout_id="nonexistent-rollout",
+                config_api_root="https://api.test.com",
+                bearer_token="test-token",
+            )