airbyte-internal-ops 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

airbyte_ops_mcp/mcp/live_tests.py

@@ -9,7 +9,6 @@ in GitHub Actions and results can be polled via workflow status.
 from __future__ import annotations
 
 import logging
-import os
 import uuid
 from datetime import datetime
 from enum import Enum
@@ -21,6 +20,11 @@ from airbyte.cloud.auth import resolve_cloud_client_id, resolve_cloud_client_sec
 from fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
+from airbyte_ops_mcp.github_actions import (
+    GITHUB_API_BASE,
+    resolve_github_token,
+    trigger_workflow_dispatch,
+)
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 
 logger = logging.getLogger(__name__)
@@ -29,7 +33,6 @@ logger = logging.getLogger(__name__)
 # GitHub Workflow Configuration
 # =============================================================================
 
-GITHUB_API_BASE = "https://api.github.com"
 LIVE_TEST_REPO_OWNER = "airbytehq"
 LIVE_TEST_REPO_NAME = "airbyte-ops-mcp"
 LIVE_TEST_DEFAULT_BRANCH = "main"
@@ -37,76 +40,6 @@ LIVE_TEST_WORKFLOW_FILE = "connector-live-test.yml"
 REGRESSION_TEST_WORKFLOW_FILE = "connector-regression-test.yml"
 
 
-# =============================================================================
-# GitHub API Helper Functions
-# =============================================================================
-
-
-def _get_github_token() -> str:
-    """Get GitHub token from environment.
-
-    Checks for tokens in order of specificity:
-    1. GITHUB_CI_WORKFLOW_TRIGGER_PAT (general workflow triggering)
-    2. GITHUB_TOKEN (fallback)
-
-    Returns:
-        GitHub token string.
-
-    Raises:
-        ValueError: If no GitHub token environment variable is set.
-    """
-    token = os.getenv("GITHUB_CI_WORKFLOW_TRIGGER_PAT") or os.getenv("GITHUB_TOKEN")
-    if not token:
-        raise ValueError(
-            "No GitHub token found. Set GITHUB_CI_WORKFLOW_TRIGGER_PAT or GITHUB_TOKEN "
-            "environment variable with 'actions:write' permission."
-        )
-    return token
-
-
-def _trigger_workflow_dispatch(
-    owner: str,
-    repo: str,
-    workflow_file: str,
-    ref: str,
-    inputs: dict[str, Any],
-    token: str,
-) -> str:
-    """Trigger a GitHub Actions workflow via workflow_dispatch.
-
-    Args:
-        owner: Repository owner (e.g., "airbytehq")
-        repo: Repository name (e.g., "airbyte-ops-mcp")
-        workflow_file: Workflow file name (e.g., "connector-live-test.yml")
-        ref: Git ref to run the workflow on (branch name)
-        inputs: Workflow inputs dictionary
-        token: GitHub API token
-
-    Returns:
-        URL to view workflow runs.
-
-    Raises:
-        requests.HTTPError: If API request fails.
-    """
-    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/actions/workflows/{workflow_file}/dispatches"
-    headers = {
-        "Authorization": f"Bearer {token}",
-        "Accept": "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-    }
-    payload = {
-        "ref": ref,
-        "inputs": inputs,
-    }
-
-    response = requests.post(url, headers=headers, json=payload, timeout=30)
-    response.raise_for_status()
-
-    # workflow_dispatch returns 204 No Content on success
-    # Return URL to view workflow runs
-    return f"https://github.com/{owner}/{repo}/actions/workflows/{workflow_file}"
-
-
 def _get_workflow_run_status(
     owner: str,
     repo: str,
@@ -293,12 +226,22 @@ class LiveConnectionTestResult(BaseModel):
 class RunLiveConnectionTestsResponse(BaseModel):
     """Response from starting a live connection test via GitHub Actions workflow."""
 
-    run_id: str = Field(description="Unique identifier for the test run")
+    run_id: str = Field(
+        description="Unique identifier for the test run (internal tracking ID)"
+    )
     status: TestRunStatus = Field(description="Initial status of the test run")
     message: str = Field(description="Human-readable status message")
     workflow_url: str | None = Field(
         default=None,
-        description="URL to view the GitHub Actions workflow runs",
+        description="URL to view the GitHub Actions workflow file",
+    )
+    github_run_id: int | None = Field(
+        default=None,
+        description="GitHub Actions workflow run ID (use with check_workflow_status)",
+    )
+    github_run_url: str | None = Field(
+        default=None,
+        description="Direct URL to the GitHub Actions workflow run",
     )
 
 
@@ -348,9 +291,16 @@ def run_live_connection_tests(
     ] = None,
     connector_name: Annotated[
         str | None,
-        "Connector name to build target image from source for regression tests "
-        "(e.g., 'source-pokeapi'). If provided, builds the target image locally. "
-        "Only used when skip_regression_tests=False.",
+        "Connector name to build the connector image from source "
+        "(e.g., 'source-pokeapi'). If provided, builds the image locally with tag 'dev'. "
+        "For live tests, this builds the test image. For regression tests, this builds "
+        "the target image while control is auto-detected from the connection.",
+    ] = None,
+    pr: Annotated[
+        int | None,
+        "PR number from the airbyte monorepo to checkout and build from "
+        "(e.g., 70847). Only used when connector_name is provided. "
+        "If not specified, builds from the default branch (master).",
     ] = None,
 ) -> RunLiveConnectionTestsResponse:
     """Start a live connection test run via GitHub Actions workflow.
@@ -377,7 +327,7 @@ def run_live_connection_tests(
 
     # Get GitHub token
     try:
-        token = _get_github_token()
+        token = resolve_github_token()
     except ValueError as e:
         return RunLiveConnectionTestsResponse(
             run_id=run_id,
@@ -422,9 +372,13 @@ def run_live_connection_tests(
         }
         if connector_image:
             workflow_inputs["connector_image"] = connector_image
+        if connector_name:
+            workflow_inputs["connector_name"] = connector_name
+            if pr:
+                workflow_inputs["pr"] = str(pr)
 
         try:
-            workflow_url = _trigger_workflow_dispatch(
+            dispatch_result = trigger_workflow_dispatch(
                 owner=LIVE_TEST_REPO_OWNER,
                 repo=LIVE_TEST_REPO_NAME,
                 workflow_file=LIVE_TEST_WORKFLOW_FILE,
@@ -441,12 +395,15 @@ def run_live_connection_tests(
                 workflow_url=None,
             )
 
+        view_url = dispatch_result.run_url or dispatch_result.workflow_url
         return RunLiveConnectionTestsResponse(
             run_id=run_id,
             status=TestRunStatus.QUEUED,
             message=f"Live-test workflow triggered for connection {connection_id}. "
-            f"View progress at: {workflow_url}",
-            workflow_url=workflow_url,
+            f"View progress at: {view_url}",
+            workflow_url=dispatch_result.workflow_url,
+            github_run_id=dispatch_result.run_id,
+            github_run_url=dispatch_result.run_url,
         )
 
     # Regression test workflow (skip_regression_tests=False)
@@ -472,9 +429,11 @@ def run_live_connection_tests(
         workflow_inputs["control_image"] = control_image
     if connector_name:
         workflow_inputs["connector_name"] = connector_name
+        if pr:
+            workflow_inputs["pr"] = str(pr)
 
     try:
-        workflow_url = _trigger_workflow_dispatch(
+        dispatch_result = trigger_workflow_dispatch(
             owner=LIVE_TEST_REPO_OWNER,
             repo=LIVE_TEST_REPO_NAME,
             workflow_file=REGRESSION_TEST_WORKFLOW_FILE,
@@ -491,12 +450,15 @@ def run_live_connection_tests(
             workflow_url=None,
         )
 
+    view_url = dispatch_result.run_url or dispatch_result.workflow_url
     return RunLiveConnectionTestsResponse(
         run_id=run_id,
         status=TestRunStatus.QUEUED,
         message=f"Regression-test workflow triggered for connection {connection_id}. "
-        f"View progress at: {workflow_url}",
-        workflow_url=workflow_url,
+        f"View progress at: {view_url}",
+        workflow_url=dispatch_result.workflow_url,
+        github_run_id=dispatch_result.run_id,
+        github_run_url=dispatch_result.run_url,
     )
 
 

airbyte_ops_mcp/mcp/prerelease.py

@@ -8,7 +8,6 @@ workflow in the airbytehq/airbyte repository via GitHub's workflow dispatch API.
 from __future__ import annotations
 
 import base64
-import os
 from typing import Annotated, Literal
 
 import requests
@@ -16,15 +15,22 @@ import yaml
 from fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
+from airbyte_ops_mcp.github_actions import GITHUB_API_BASE, resolve_github_token
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 
-GITHUB_API_BASE = "https://api.github.com"
 DEFAULT_REPO_OWNER = "airbytehq"
 DEFAULT_REPO_NAME = "airbyte"
 DEFAULT_BRANCH = "master"
 PRERELEASE_WORKFLOW_FILE = "publish-connectors-prerelease-command.yml"
 CONNECTOR_PATH_PREFIX = "airbyte-integrations/connectors"
 
+# Token env vars for prerelease publishing (in order of preference)
+PRERELEASE_TOKEN_ENV_VARS = [
+    "GITHUB_CONNECTOR_PUBLISHING_PAT",
+    "GITHUB_CI_WORKFLOW_TRIGGER_PAT",
+    "GITHUB_TOKEN",
+]
+
 
 class PRHeadInfo(BaseModel):
     """Information about a PR's head commit."""
@@ -46,34 +52,6 @@ class PrereleaseWorkflowResult(BaseModel):
     docker_image_tag: str | None = None
 
 
-def _get_github_token() -> str:
-    """Get GitHub token from environment.
-
-    Checks for tokens in order of specificity:
-    1. GITHUB_CONNECTOR_PUBLISHING_PAT (most specific)
-    2. GITHUB_CI_WORKFLOW_TRIGGER_PAT (general workflow triggering)
-    3. GITHUB_TOKEN (fallback)
-
-    Returns:
-        GitHub token string.
-
-    Raises:
-        ValueError: If no GitHub token environment variable is set.
-    """
-    token = (
-        os.getenv("GITHUB_CONNECTOR_PUBLISHING_PAT")
-        or os.getenv("GITHUB_CI_WORKFLOW_TRIGGER_PAT")
-        or os.getenv("GITHUB_TOKEN")
-    )
-    if not token:
-        raise ValueError(
-            "No GitHub token found. Set GITHUB_CONNECTOR_PUBLISHING_PAT, "
-            "GITHUB_CI_WORKFLOW_TRIGGER_PAT, or GITHUB_TOKEN environment variable "
-            "with 'actions:write' permission."
-        )
-    return token
-
-
 def _get_pr_head_info(
     owner: str,
     repo: str,
@@ -248,7 +226,7 @@ def publish_connector_to_airbyte_registry(
         )
 
     # Guard: Check for required token
-    token = _get_github_token()
+    token = resolve_github_token(PRERELEASE_TOKEN_ENV_VARS)
 
     # Get the PR's head ref and SHA
     head_info = _get_pr_head_info(

airbyte_ops_mcp/mcp/prod_db_queries.py

@@ -20,7 +20,7 @@ from airbyte_ops_mcp.prod_db_access.queries import (
     query_connections_by_connector,
     query_connector_versions,
     query_dataplanes_list,
-    query_failed_sync_attempts_for_version,
+    query_failed_sync_attempts_for_connector,
     query_new_connector_releases,
     query_sync_results_for_version,
     query_workspace_info,
@@ -249,12 +249,41 @@ def query_prod_connector_version_sync_results(
 @mcp_tool(
     read_only=True,
     idempotent=True,
+    open_world=True,
 )
-def query_prod_failed_sync_attempts_for_version(
-    connector_version_id: Annotated[
-        str,
-        Field(description="Connector version UUID to find failed sync attempts for"),
-    ],
+def query_prod_failed_sync_attempts_for_connector(
+    source_definition_id: Annotated[
+        str | None,
+        Field(
+            description=(
+                "Source connector definition ID (UUID) to search for. "
+                "Exactly one of this or source_canonical_name is required. "
+                "Example: 'afa734e4-3571-11ec-991a-1e0031268139' for YouTube Analytics."
+            ),
+            default=None,
+        ),
+    ] = None,
+    source_canonical_name: Annotated[
+        str | None,
+        Field(
+            description=(
+                "Canonical source connector name to search for. "
+                "Exactly one of this or source_definition_id is required. "
+                "Examples: 'source-youtube-analytics', 'YouTube Analytics'."
+            ),
+            default=None,
+        ),
+    ] = None,
+    organization_id: Annotated[
+        str | None,
+        Field(
+            description=(
+                "Optional organization ID (UUID) to filter results. "
+                "If provided, only failed attempts from this organization will be returned."
+            ),
+            default=None,
+        ),
+    ] = None,
     days: Annotated[
         int,
         Field(description="Number of days to look back (default: 7)", default=7),
@@ -264,29 +293,43 @@ def query_prod_failed_sync_attempts_for_version(
         Field(description="Maximum number of results (default: 100)", default=100),
     ] = 100,
 ) -> list[dict[str, Any]]:
-    """List failed sync attempts with failure details for actors pinned to a connector version.
+    """List failed sync attempts for ALL actors using a source connector type.
 
-    Returns failed attempt records for connections using actors pinned to the specified
-    version. Includes failure_summary from the attempts table for debugging.
+    This tool finds all actors with the given connector definition and returns their
+    failed sync attempts, regardless of whether they have explicit version pins.
 
-    Key fields:
-    - latest_job_attempt_status: Final job status after all retries ('succeeded' means
-      the job eventually succeeded despite this failed attempt)
-    - failed_attempt_number: Which attempt this was (0-indexed)
-    - failure_summary: JSON containing failure details including failureType and messages
+    This is useful for investigating connector issues across all users. Use this when
+    you want to find failures for a connector type regardless of which version users
+    are on.
 
-    Note: May return multiple rows per job (one per failed attempt). Results ordered by
-    job_updated_at DESC, then failed_attempt_number DESC.
+    Note: This tool only supports SOURCE connectors. For destination connectors,
+    a separate tool would be needed.
 
-    Returns list of dicts with keys: job_id, connection_id, latest_job_attempt_status,
-    job_started_at, job_updated_at, connection_name, actor_id, actor_name,
-    actor_definition_id, pin_origin_type, pin_origin, workspace_id, workspace_name,
-    organization_id, dataplane_group_id, dataplane_name, failed_attempt_id,
-    failed_attempt_number, failed_attempt_status, failed_attempt_created_at,
-    failed_attempt_ended_at, failure_summary, processing_task_queue
+    Key fields in results:
+    - failure_summary: JSON containing failure details including failureType and messages
+    - pin_origin_type, pin_origin, pinned_version_id: Version pin context (NULL if not pinned)
     """
-    return query_failed_sync_attempts_for_version(
-        connector_version_id,
+    # Validate that exactly one of the two parameters is provided
+    if (source_definition_id is None) == (source_canonical_name is None):
+        raise PyAirbyteInputError(
+            message=(
+                "Exactly one of source_definition_id or source_canonical_name "
+                "must be provided, but not both."
+            ),
+        )
+
+    # Resolve canonical name to definition ID if needed
+    resolved_definition_id: str
+    if source_canonical_name:
+        resolved_definition_id = _resolve_canonical_name_to_definition_id(
+            canonical_name=source_canonical_name,
+        )
+    else:
+        resolved_definition_id = source_definition_id  # type: ignore[assignment]
+
+    return query_failed_sync_attempts_for_connector(
+        connector_definition_id=resolved_definition_id,
+        organization_id=organization_id,
         days=days,
         limit=limit,
     )

airbyte_ops_mcp/mcp/server.py

@@ -2,9 +2,18 @@
 """Airbyte Admin MCP server implementation.
 
 This module provides the main MCP server for Airbyte admin operations.
+
+The server can run in two modes:
+- **stdio mode** (default): For direct MCP client connections via stdin/stdout
+- **HTTP mode**: For HTTP-based MCP connections, useful for containerized deployments
+
+Environment Variables:
+    MCP_HTTP_HOST: Host to bind HTTP server to (default: 127.0.0.1)
+    MCP_HTTP_PORT: Port for HTTP server (default: 8082)
 """
 
 import asyncio
+import os
 import sys
 from pathlib import Path
 
@@ -23,6 +32,10 @@ from airbyte_ops_mcp.mcp.prod_db_queries import register_prod_db_query_tools
 from airbyte_ops_mcp.mcp.prompts import register_prompts
 from airbyte_ops_mcp.mcp.server_info import register_server_info_resources
 
+# Default HTTP server configuration
+DEFAULT_HTTP_HOST = "127.0.0.1"
+DEFAULT_HTTP_PORT = 8082
+
 app: FastMCP = FastMCP(MCP_SERVER_NAME)
 
 
@@ -56,27 +69,87 @@ def register_server_assets(app: FastMCP) -> None:
 register_server_assets(app)
 
 
-def main() -> None:
-    """Main entry point for the Airbyte Admin MCP server."""
-    # Load environment variables from .env file in current working directory
+def _load_env() -> None:
+    """Load environment variables from .env file if present."""
     env_file = Path.cwd() / ".env"
     if env_file.exists():
         load_dotenv(env_file)
         print(f"Loaded environment from: {env_file}", flush=True, file=sys.stderr)
 
+
+def main() -> None:
+    """Main entry point for the Airbyte Admin MCP server (stdio mode).
+
+    This is the default entry point that runs the server in stdio mode,
+    suitable for direct MCP client connections.
+    """
+    _load_env()
+
     print("=" * 60, flush=True, file=sys.stderr)
-    print("Starting Airbyte Admin MCP server.", file=sys.stderr)
+    print("Starting Airbyte Admin MCP server (stdio mode).", file=sys.stderr)
     try:
         asyncio.run(app.run_stdio_async(show_banner=False))
     except KeyboardInterrupt:
         print("Airbyte Admin MCP server interrupted by user.", file=sys.stderr)
-    except Exception as ex:
-        print(f"Error running Airbyte Admin MCP server: {ex}", file=sys.stderr)
-        sys.exit(1)
 
     print("Airbyte Admin MCP server stopped.", file=sys.stderr)
     print("=" * 60, flush=True, file=sys.stderr)
-    sys.exit(0)
+
+
+def _parse_port(port_str: str | None, default: int) -> int:
+    """Parse and validate a port number from string.
+
+    Args:
+        port_str: Port string from environment variable, or None if not set
+        default: Default port to use if port_str is None
+
+    Returns:
+        Validated port number
+
+    Raises:
+        ValueError: If port_str is not a valid integer or out of range
+    """
+    if port_str is None:
+        return default
+
+    port_str = port_str.strip()
+    if not port_str.isdecimal():
+        raise ValueError(f"MCP_HTTP_PORT must be a valid integer, got: {port_str!r}")
+
+    port = int(port_str)
+    if not 1 <= port <= 65535:
+        raise ValueError(f"MCP_HTTP_PORT must be between 1 and 65535, got: {port}")
+
+    return port
+
+
+def main_http() -> None:
+    """HTTP entry point for the Airbyte Admin MCP server.
+
+    This entry point runs the server in HTTP mode, suitable for containerized
+    deployments where the server needs to be accessible over HTTP.
+
+    Environment Variables:
+        MCP_HTTP_HOST: Host to bind to (default: 127.0.0.1)
+        MCP_HTTP_PORT: Port to listen on (default: 8082)
+    """
+    _load_env()
+
+    host = os.getenv("MCP_HTTP_HOST", DEFAULT_HTTP_HOST)
+    port = _parse_port(os.getenv("MCP_HTTP_PORT"), DEFAULT_HTTP_PORT)
+
+    print("=" * 60, flush=True, file=sys.stderr)
+    print(
+        f"Starting Airbyte Admin MCP server (HTTP mode) on {host}:{port}",
+        file=sys.stderr,
+    )
+    try:
+        app.run(transport="http", host=host, port=port)
+    except KeyboardInterrupt:
+        print("Airbyte Admin MCP server interrupted by user.", file=sys.stderr)
+
+    print("Airbyte Admin MCP server stopped.", file=sys.stderr)
+    print("=" * 60, flush=True, file=sys.stderr)
 
 
 if __name__ == "__main__":

airbyte_ops_mcp/prod_db_access/db_engine.py

@@ -52,6 +52,7 @@ def _is_tailscale_connected() -> bool:
     Detection methods:
     1. Check for tailscale0 network interface (Linux)
     2. Run 'tailscale status --json' and check backend state (cross-platform)
+    3. Check macOS-specific Tailscale.app location if tailscale not in PATH
     """
     # Method 1: Check for tailscale0 interface (Linux)
     try:
@@ -63,6 +64,13 @@ def _is_tailscale_connected() -> bool:
 
     # Method 2: Check tailscale CLI status
     tailscale_path = shutil.which("tailscale")
+
+    # Method 3: On macOS, check the standard Tailscale.app location if not in PATH
+    if not tailscale_path and os.path.exists(
+        "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+    ):
+        tailscale_path = "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+
     if tailscale_path:
         try:
             result = subprocess.run(

airbyte_ops_mcp/prod_db_access/queries.py

@@ -24,7 +24,7 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG,
     SELECT_CONNECTOR_VERSIONS,
     SELECT_DATAPLANES_LIST,
-    SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION,
+    SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR,
     SELECT_NEW_CONNECTOR_RELEASES,
     SELECT_ORG_WORKSPACES,
     SELECT_SUCCESSFUL_SYNCS_FOR_VERSION,
@@ -225,43 +225,55 @@ def query_sync_results_for_version(
     )
 
 
-def query_failed_sync_attempts_for_version(
-    connector_version_id: str,
+def query_failed_sync_attempts_for_connector(
+    connector_definition_id: str,
+    organization_id: str | None = None,
     days: int = 7,
     limit: int = 100,
     *,
     gsm_client: secretmanager.SecretManagerServiceClient | None = None,
 ) -> list[dict[str, Any]]:
-    """Query failed sync job results with attempt details for actors pinned to a version.
+    """Query failed sync attempts for ALL actors using a connector definition.
 
-    This query joins to the attempts table to include failure_summary and other
-    attempt-level details useful for debugging. Date filters are applied to both
-    jobs and attempts tables to optimize join performance.
+    Finds all actors with the given actor_definition_id and returns their failed
+    sync attempts, regardless of whether they have explicit version pins.
 
-    Note: This may return multiple rows per job (one per attempt). Results are
-    ordered by job_updated_at DESC, then attempt_number DESC.
+    This is useful for investigating connector issues across all users.
+
+    Note: This query only supports SOURCE connectors (joins via connection.source_id).
+    For destination connectors, a separate query would be needed.
 
     Args:
-        connector_version_id: Connector version UUID to filter by
+        connector_definition_id: Connector definition UUID to filter by
+        organization_id: Optional organization UUID to filter results by (post-query filter)
         days: Number of days to look back (default: 7)
         limit: Maximum number of results (default: 100)
         gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
 
     Returns:
-        List of failed sync job results with attempt details including failure_summary
+        List of failed sync attempt records with failure_summary and workspace info
     """
     cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
-    return _run_sql_query(
-        SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION,
+
+    results = _run_sql_query(
+        SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR,
         parameters={
-            "actor_definition_version_id": connector_version_id,
+            "connector_definition_id": connector_definition_id,
             "cutoff_date": cutoff_date,
             "limit": limit,
         },
-        query_name="SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION",
+        query_name="SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR",
         gsm_client=gsm_client,
     )
 
+    # Post-query filter by organization_id if provided
+    if organization_id is not None:
+        results = [
+            r for r in results if str(r.get("organization_id")) == organization_id
+        ]
+
+    return results
+
 
 def query_dataplanes_list(
     *,