airbyte-internal-ops 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

airbyte_ops_mcp/mcp/prod_db_queries.py

@@ -16,12 +16,13 @@ from airbyte.exceptions import PyAirbyteInputError
 from fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
-from airbyte_ops_mcp.constants import OrganizationAliasEnum
+from airbyte_ops_mcp.constants import OrganizationAliasEnum, WorkspaceAliasEnum
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 from airbyte_ops_mcp.prod_db_access.queries import (
     query_actors_pinned_to_version,
     query_connections_by_connector,
     query_connections_by_destination_connector,
+    query_connections_by_stream,
     query_connector_versions,
     query_dataplanes_list,
     query_destination_connection_stats,
@@ -299,8 +300,11 @@ def query_prod_dataplanes() -> list[dict[str, Any]]:
 )
 def query_prod_workspace_info(
     workspace_id: Annotated[
-        str,
-        Field(description="Workspace UUID to look up"),
+        str | WorkspaceAliasEnum,
+        Field(
+            description="Workspace UUID or alias to look up. "
+            "Accepts '@devin-ai-sandbox' as an alias for the Devin AI sandbox workspace."
+        ),
     ],
 ) -> dict[str, Any] | None:
     """Get workspace information including dataplane group.
@@ -313,7 +317,11 @@ def query_prod_workspace_info(
     dataplane_group_id, dataplane_name, created_at, tombstone
     Or None if workspace not found.
     """
-    return query_workspace_info(workspace_id)
+    # Resolve workspace ID alias (workspace_id is required, so resolved value is never None)
+    resolved_workspace_id = WorkspaceAliasEnum.resolve(workspace_id)
+    assert resolved_workspace_id is not None  # Type narrowing: workspace_id is required
+
+    return query_workspace_info(resolved_workspace_id)
 
 
 @mcp_tool(
@@ -868,6 +876,122 @@ def query_prod_connections_by_connector(
     ]
 
 
+@mcp_tool(
+    read_only=True,
+    idempotent=True,
+    open_world=True,
+)
+def query_prod_connections_by_stream(
+    stream_name: Annotated[
+        str,
+        Field(
+            description=(
+                "Name of the stream to search for in connection catalogs. "
+                "This must match the exact stream name as configured in the connection. "
+                "Examples: 'global_exclusions', 'campaigns', 'users'."
+            ),
+        ),
+    ],
+    source_definition_id: Annotated[
+        str | None,
+        Field(
+            description=(
+                "Source connector definition ID (UUID) to search for. "
+                "Provide this OR source_canonical_name (exactly one required). "
+                "Example: 'afa734e4-3571-11ec-991a-1e0031268139' for YouTube Analytics."
+            ),
+            default=None,
+        ),
+    ],
+    source_canonical_name: Annotated[
+        str | None,
+        Field(
+            description=(
+                "Canonical source connector name to search for. "
+                "Provide this OR source_definition_id (exactly one required). "
+                "Examples: 'source-klaviyo', 'Klaviyo', 'source-youtube-analytics'."
+            ),
+            default=None,
+        ),
+    ],
+    organization_id: Annotated[
+        str | OrganizationAliasEnum | None,
+        Field(
+            description=(
+                "Optional organization ID (UUID) or alias to filter results. "
+                "If provided, only connections in this organization will be returned. "
+                "Accepts '@airbyte-internal' as an alias for the Airbyte internal org."
+            ),
+            default=None,
+        ),
+    ],
+    limit: Annotated[
+        int,
+        Field(description="Maximum number of results (default: 100)", default=100),
+    ],
+) -> list[dict[str, Any]]:
+    """Find connections that have a specific stream enabled in their catalog.
+
+    This tool searches the connection's configured catalog (JSONB) for streams
+    matching the specified name. It's particularly useful when validating
+    connector fixes that affect specific streams - you can quickly find
+    customer connections that use the affected stream.
+
+    Use cases:
+    - Finding connections with a specific stream enabled for regression testing
+    - Validating connector fixes that affect particular streams
+    - Identifying which customers use rarely-enabled streams
+
+    Returns a list of connection dicts with workspace context and clickable Cloud UI URLs.
+    """
+    provided_params = [source_definition_id, source_canonical_name]
+    num_provided = sum(p is not None for p in provided_params)
+    if num_provided != 1:
+        raise PyAirbyteInputError(
+            message=(
+                "Exactly one of source_definition_id or source_canonical_name "
+                "must be provided."
+            ),
+        )
+
+    resolved_definition_id: str
+    if source_canonical_name:
+        resolved_definition_id = _resolve_canonical_name_to_definition_id(
+            canonical_name=source_canonical_name,
+        )
+    else:
+        assert source_definition_id is not None
+        resolved_definition_id = source_definition_id
+
+    resolved_organization_id = OrganizationAliasEnum.resolve(organization_id)
+
+    return [
+        {
+            "organization_id": str(row.get("organization_id", "")),
+            "workspace_id": str(row["workspace_id"]),
+            "workspace_name": row.get("workspace_name", ""),
+            "connection_id": str(row["connection_id"]),
+            "connection_name": row.get("connection_name", ""),
+            "connection_status": row.get("connection_status", ""),
+            "connection_url": (
+                f"{CLOUD_UI_BASE_URL}/workspaces/{row['workspace_id']}"
+                f"/connections/{row['connection_id']}/status"
+            ),
+            "source_id": str(row["source_id"]),
+            "source_name": row.get("source_name", ""),
+            "source_definition_id": str(row["source_definition_id"]),
+            "dataplane_group_id": str(row.get("dataplane_group_id", "")),
+            "dataplane_name": row.get("dataplane_name", ""),
+        }
+        for row in query_connections_by_stream(
+            connector_definition_id=resolved_definition_id,
+            stream_name=stream_name,
+            organization_id=resolved_organization_id,
+            limit=limit,
+        )
+    ]
+
+
 @mcp_tool(
     read_only=True,
     idempotent=True,

airbyte_ops_mcp/mcp/regression_tests.py

@@ -31,6 +31,7 @@ from airbyte.exceptions import (
 from fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
+from airbyte_ops_mcp.constants import WorkspaceAliasEnum
 from airbyte_ops_mcp.github_actions import trigger_workflow_dispatch
 from airbyte_ops_mcp.github_api import GITHUB_API_BASE, resolve_github_token
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
@@ -341,9 +342,10 @@ def run_regression_tests(
         "Ignored if skip_compare=True.",
     ] = None,
     workspace_id: Annotated[
-        str | None,
-        "Optional Airbyte Cloud workspace ID. If provided with connection_id, validates "
-        "that the connection belongs to this workspace before triggering tests.",
+        str | WorkspaceAliasEnum | None,
+        "Optional Airbyte Cloud workspace ID (UUID) or alias. If provided with connection_id, "
+        "validates that the connection belongs to this workspace before triggering tests. "
+        "Accepts '@devin-ai-sandbox' as an alias for the Devin AI sandbox workspace.",
     ] = None,
 ) -> RunRegressionTestsResponse:
     """Start a regression test run via GitHub Actions workflow.
@@ -368,6 +370,9 @@ def run_regression_tests(
     Requires GITHUB_CI_WORKFLOW_TRIGGER_PAT or GITHUB_TOKEN environment variable
     with 'actions:write' permission.
     """
+    # Resolve workspace ID alias
+    resolved_workspace_id = WorkspaceAliasEnum.resolve(workspace_id)
+
     # Generate a unique run ID for tracking
     run_id = str(uuid.uuid4())
 
@@ -383,9 +388,9 @@ def run_regression_tests(
         )
 
     # Validate workspace membership if workspace_id and connection_id are provided
-    if workspace_id and connection_id:
+    if resolved_workspace_id and connection_id:
         try:
-            validate_connection_workspace(connection_id, workspace_id)
+            validate_connection_workspace(connection_id, resolved_workspace_id)
         except (
             ValueError,
             AirbyteWorkspaceMismatchError,

airbyte_ops_mcp/{_legacy/airbyte_ci/metadata_service/validators/metadata_validator.py → metadata_validator.py}

@@ -1,6 +1,12 @@
 #
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
+"""Connector metadata validation for Airbyte connectors.
+
+Provides validation functions for connector metadata.yaml files, including checks
+for Docker image availability, version constraints, breaking changes, and registry
+configuration. Uses Pydantic models from airbyte-connector-models for schema validation.
+"""
 
 import logging
 import pathlib
@@ -9,14 +15,13 @@ from typing import Callable, List, Optional, Tuple, Union
 
 import semver
 import yaml
+from airbyte_connector_models.metadata.v0.connector_metadata_definition_v0 import (
+    ConnectorMetadataDefinitionV0,
+)
 from pydantic import ValidationError
 from pydash.objects import get
 
-from airbyte_ops_mcp._legacy.airbyte_ci.metadata_models.generated.ConnectorMetadataDefinitionV0 import (
-    ConnectorMetadataDefinitionV0,
-)  # type: ignore
-
-from ..docker_hub import get_latest_version_on_dockerhub, is_image_on_docker_hub
+from .docker_hub import get_latest_version_on_dockerhub, is_image_on_docker_hub
 
 logger = logging.getLogger(__name__)
 
@@ -42,7 +47,7 @@ def validate_metadata_images_in_dockerhub(
     if validator_opts.disable_dockerhub_checks:
         return True, None
 
-    metadata_definition_dict = metadata_definition.dict()
+    metadata_definition_dict = metadata_definition.model_dump(exclude_unset=True)
     base_docker_image = get(metadata_definition_dict, "data.dockerRepository")
     base_docker_version = get(metadata_definition_dict, "data.dockerImageTag")
 
@@ -111,7 +116,7 @@ def validate_at_least_one_language_tag(
 ) -> ValidationResult:
     """Ensure that there is at least one tag in the data.tags field that matches language:<LANG>."""
     tags = get(metadata_definition, "data.tags", [])
-    if not any([tag.startswith("language:") for tag in tags]):
+    if not any(tag.startswith("language:") for tag in tags):
         return False, "At least one tag must be of the form language:<LANG>"
 
     return True, None
@@ -145,7 +150,7 @@ def validate_major_version_bump_has_breaking_change_entry(
     _validator_opts: ValidatorOptions,
 ) -> ValidationResult:
     """Ensure that if the major version is incremented, there is a breaking change entry for that version."""
-    metadata_definition_dict = metadata_definition.dict()
+    metadata_definition_dict = metadata_definition.model_dump(exclude_unset=True)
     image_tag = get(metadata_definition_dict, "data.dockerImageTag")
 
     if not is_major_version(image_tag):
@@ -169,7 +174,7 @@ def validate_major_version_bump_has_breaking_change_entry(
         )
 
     breaking_changes = get(metadata_definition_dict, "data.releases.breakingChanges")
-    if breaking_changes is None or image_tag not in breaking_changes.keys():
+    if breaking_changes is None or image_tag not in breaking_changes:
         return (
             False,
             f"Major version {image_tag} needs a 'releases.breakingChanges' entry indicating what changed.",
@@ -194,7 +199,7 @@ def validate_metadata_base_images_in_dockerhub(
     if validator_opts.disable_dockerhub_checks:
         return True, None
 
-    metadata_definition_dict = metadata_definition.dict()
+    metadata_definition_dict = metadata_definition.model_dump(exclude_unset=True)
 
     image_address = get(
         metadata_definition_dict, "data.connectorBuildOptions.baseImage"
@@ -365,7 +370,8 @@ PRE_UPLOAD_VALIDATORS = [
 ]
 
 
-POST_UPLOAD_VALIDATORS = PRE_UPLOAD_VALIDATORS + [
+POST_UPLOAD_VALIDATORS = [
+    *PRE_UPLOAD_VALIDATORS,
     validate_metadata_images_in_dockerhub,
 ]
 
@@ -384,7 +390,7 @@ def validate_and_load(
     try:
         # Load the metadata file - this implicitly runs jsonschema validation
         metadata = yaml.safe_load(file_path.read_text())
-        metadata_model = ConnectorMetadataDefinitionV0.parse_obj(metadata)
+        metadata_model = ConnectorMetadataDefinitionV0.model_validate(metadata)
     except ValidationError as e:
         return None, f"Validation error: {e}"
 

airbyte_ops_mcp/prod_db_access/queries.py

@@ -24,6 +24,8 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG,
     SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR,
     SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR_AND_ORG,
+    SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM,
+    SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM_AND_ORG,
     SELECT_CONNECTOR_VERSIONS,
     SELECT_DATAPLANES_LIST,
     SELECT_DESTINATION_CONNECTION_STATS,
@@ -565,3 +567,52 @@ def query_destination_connection_stats(
         query_name="SELECT_DESTINATION_CONNECTION_STATS",
         gsm_client=gsm_client,
     )
+
+
+def query_connections_by_stream(
+    connector_definition_id: str,
+    stream_name: str,
+    organization_id: str | None = None,
+    limit: int = 100,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query connections by source connector type that have a specific stream enabled.
+
+    This searches the connection's configured catalog (JSONB) for streams matching
+    the specified name. Useful for finding connections that use a particular stream
+    when validating connector fixes that affect specific streams.
+
+    Args:
+        connector_definition_id: Source connector definition UUID to filter by
+        stream_name: Name of the stream to search for in the connection's catalog
+        organization_id: Optional organization UUID to filter results by
+        limit: Maximum number of results (default: 100)
+        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
+
+    Returns:
+        List of connection records with workspace and dataplane info
+    """
+    if organization_id is None:
+        return _run_sql_query(
+            SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM,
+            parameters={
+                "connector_definition_id": connector_definition_id,
+                "stream_name": stream_name,
+                "limit": limit,
+            },
+            query_name="SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM",
+            gsm_client=gsm_client,
+        )
+
+    return _run_sql_query(
+        SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM_AND_ORG,
+        parameters={
+            "connector_definition_id": connector_definition_id,
+            "stream_name": stream_name,
+            "organization_id": organization_id,
+            "limit": limit,
+        },
+        query_name="SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM_AND_ORG",
+        gsm_client=gsm_client,
+    )

airbyte_ops_mcp/prod_db_access/sql.py

@@ -934,3 +934,79 @@ SELECT_DESTINATION_CONNECTION_STATS = sqlalchemy.text(
     ORDER BY total_connections DESC
     """
 )
+
+# =============================================================================
+# Stream-based Connection Queries
+# =============================================================================
+
+# Query connections by source connector type that have a specific stream enabled
+# The catalog field is JSONB with structure: {"streams": [{"stream": {"name": "..."}, ...}, ...]}
+SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM = sqlalchemy.text(
+    """
+    SELECT
+         connection.id AS connection_id,
+         connection.name AS connection_name,
+         connection.source_id,
+         connection.status AS connection_status,
+         workspace.id AS workspace_id,
+         workspace.name AS workspace_name,
+         workspace.organization_id,
+         workspace.dataplane_group_id,
+         dataplane_group.name AS dataplane_name,
+         source_actor.actor_definition_id AS source_definition_id,
+         source_actor.name AS source_name
+    FROM connection
+    JOIN actor AS source_actor
+      ON connection.source_id = source_actor.id
+     AND source_actor.tombstone = false
+    JOIN workspace
+      ON source_actor.workspace_id = workspace.id
+     AND workspace.tombstone = false
+    LEFT JOIN dataplane_group
+      ON workspace.dataplane_group_id = dataplane_group.id
+    WHERE
+         source_actor.actor_definition_id = :connector_definition_id
+     AND connection.status = 'active'
+     AND EXISTS (
+         SELECT 1 FROM jsonb_array_elements(connection.catalog->'streams') AS stream
+         WHERE stream->'stream'->>'name' = :stream_name
+     )
+    LIMIT :limit
+    """
+)
+
+# Query connections by source connector type and stream, filtered by organization
+SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM_AND_ORG = sqlalchemy.text(
+    """
+    SELECT
+         connection.id AS connection_id,
+         connection.name AS connection_name,
+         connection.source_id,
+         connection.status AS connection_status,
+         workspace.id AS workspace_id,
+         workspace.name AS workspace_name,
+         workspace.organization_id,
+         workspace.dataplane_group_id,
+         dataplane_group.name AS dataplane_name,
+         source_actor.actor_definition_id AS source_definition_id,
+         source_actor.name AS source_name
+    FROM connection
+    JOIN actor AS source_actor
+      ON connection.source_id = source_actor.id
+     AND source_actor.tombstone = false
+    JOIN workspace
+      ON source_actor.workspace_id = workspace.id
+     AND workspace.tombstone = false
+    LEFT JOIN dataplane_group
+      ON workspace.dataplane_group_id = dataplane_group.id
+    WHERE
+         source_actor.actor_definition_id = :connector_definition_id
+     AND workspace.organization_id = :organization_id
+     AND connection.status = 'active'
+     AND EXISTS (
+         SELECT 1 FROM jsonb_array_elements(connection.catalog->'streams') AS stream
+         WHERE stream->'stream'->>'name' = :stream_name
+     )
+    LIMIT :limit
+    """
+)

airbyte_ops_mcp/regression_tests/ci_output.py

@@ -308,10 +308,10 @@ def generate_action_test_comparison_report(
             [
                 "#### HTTP Metrics",
                 "",
-                "| Version | Flow Count | Duplicate Flows |",
-                "|---------|------------|-----------------|",
-                f"| Control | {control_http.get('flow_count', 0)} | {control_http.get('duplicate_flow_count', 0)} |",
-                f"| Target | {target_http.get('flow_count', 0)} | {target_http.get('duplicate_flow_count', 0)} |",
+                "| Version | Flow Count | Duplicate Flows | Cache Hit Ratio |",
+                "|---------|------------|-----------------|-----------------|",
+                f"| Control | {control_http.get('flow_count', 0)} | {control_http.get('duplicate_flow_count', 0)} | {control_http.get('cache_hit_ratio', 'N/A')} |",
+                f"| Target | {target_http.get('flow_count', 0)} | {target_http.get('duplicate_flow_count', 0)} | {target_http.get('cache_hit_ratio', 'N/A')} |",
                 "",
             ]
         )
@@ -370,6 +370,9 @@ def generate_single_version_report(
     run_url = _get_github_run_url()
     artifacts_url = _get_github_artifacts_url()
 
+    # Get tester identity from environment (GitHub Actions sets GITHUB_ACTOR)
+    tester = os.getenv("GITHUB_ACTOR") or os.getenv("USER") or "unknown"
+
     # Start with L2 header containing the command name (no L1 header)
     lines: list[str] = [
         f"## `{command.upper()}` Test Results",
@@ -377,6 +380,7 @@ def generate_single_version_report(
         "### Context",
         "",
         f"- **Test Date:** {datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}",
+        f"- **Tester:** `{tester}`",
         f"- **Connector:** `{connector_name}`",
         f"- **Version:** `{version}`",
         f"- **Command:** `{command.upper()}`",

airbyte_ops_mcp/regression_tests/connection_fetcher.py

@@ -96,7 +96,7 @@ def fetch_connection_data(
         )
 
     access_token = _get_access_token(client_id, client_secret)
-    api_root = constants.CLOUD_API_ROOT
+    public_api_root = constants.CLOUD_API_ROOT
     headers = {
         "Authorization": f"Bearer {access_token}",
         "Content-Type": "application/json",
@@ -104,7 +104,7 @@ def fetch_connection_data(
 
     # Get connection details
     conn_response = requests.get(
-        f"{api_root}/connections/{connection_id}",
+        f"{public_api_root}/connections/{connection_id}",
         headers=headers,
         timeout=30,
     )
@@ -120,7 +120,7 @@ def fetch_connection_data(
 
     # Get source details (includes config)
     source_response = requests.get(
-        f"{api_root}/sources/{source_id}",
+        f"{public_api_root}/sources/{source_id}",
         headers=headers,
         timeout=30,
     )
@@ -160,7 +160,9 @@ def fetch_connection_data(
     stream_names = [s["name"] for s in streams_config]
 
     # Build Airbyte protocol catalog format
-    catalog = _build_configured_catalog(streams_config, source_id, headers, api_root)
+    catalog = _build_configured_catalog(
+        streams_config, source_id, headers, public_api_root
+    )
 
     return ConnectionData(
         connection_id=connection_id,
@@ -179,12 +181,21 @@ def _build_configured_catalog(
     streams_config: list[dict[str, Any]],
     source_id: str,
     headers: dict[str, str],
-    api_root: str,
+    public_api_root: str,
 ) -> dict[str, Any]:
     """Build a configured catalog from connection stream configuration.
 
     This creates a catalog in the Airbyte protocol format that can be used
     with connector commands.
+
+    Args:
+        streams_config: List of stream configuration dicts from the connection.
+        source_id: The source ID.
+        headers: HTTP headers for API requests.
+        public_api_root: The Public API root URL (e.g., CLOUD_API_ROOT).
+
+    Returns:
+        A configured catalog dict in Airbyte protocol format.
     """
     # For now, create a minimal catalog structure
     # A full implementation would fetch the source's discovered catalog

airbyte_ops_mcp/regression_tests/http_metrics.py

@@ -47,11 +47,21 @@ class HttpMetrics:
     flow_count: int
     duplicate_flow_count: int
     unique_urls: list[str]
+    cache_hits_count: int = 0
+
+    @property
+    def cache_hit_ratio(self) -> str:
+        """Calculate cache hit ratio as a percentage string."""
+        if self.flow_count == 0:
+            return "N/A"
+        return f"{(self.cache_hits_count / self.flow_count) * 100:.2f}%"
 
     @classmethod
     def empty(cls) -> HttpMetrics:
         """Create empty metrics when HTTP capture is unavailable."""
-        return cls(flow_count=0, duplicate_flow_count=0, unique_urls=[])
+        return cls(
+            flow_count=0, duplicate_flow_count=0, unique_urls=[], cache_hits_count=0
+        )
 
 
 @dataclass
@@ -285,17 +295,22 @@ def parse_http_dump(dump_file_path: Path) -> HttpMetrics:
     unique_urls = list(set(all_urls))
     duplicate_count = len(all_urls) - len(unique_urls)
 
+    # Cache hits are interpreted as duplicate requests to the same URL
+    # (requests that could potentially be served from cache)
+    cache_hits = duplicate_count
+
     return HttpMetrics(
         flow_count=len(flows),
         duplicate_flow_count=duplicate_count,
         unique_urls=sorted(unique_urls),
+        cache_hits_count=cache_hits,
     )
 
 
 def compute_http_metrics_comparison(
     control_metrics: HttpMetrics,
     target_metrics: HttpMetrics,
-) -> dict[str, dict[str, int | str] | int]:
+) -> dict[str, dict[str, int | str] | int | str]:
     """Compute HTTP metrics comparison between control and target.
 
     This produces output in the same format as the legacy
@@ -312,10 +327,14 @@ def compute_http_metrics_comparison(
         "control": {
             "flow_count": control_metrics.flow_count,
             "duplicate_flow_count": control_metrics.duplicate_flow_count,
+            "cache_hits_count": control_metrics.cache_hits_count,
+            "cache_hit_ratio": control_metrics.cache_hit_ratio,
         },
         "target": {
             "flow_count": target_metrics.flow_count,
             "duplicate_flow_count": target_metrics.duplicate_flow_count,
+            "cache_hits_count": target_metrics.cache_hits_count,
+            "cache_hit_ratio": target_metrics.cache_hit_ratio,
         },
         "difference": target_metrics.flow_count - control_metrics.flow_count,
     }

airbyte_ops_mcp/regression_tests/models.py

@@ -250,10 +250,16 @@ class ExecutionResult:
         messages_by_type: dict[str, list[str]] = defaultdict(list)
         for message in self.airbyte_messages:
             type_name = message.type.value.lower()
-            messages_by_type[type_name].append(message.json())
+            messages_by_type[type_name].append(message.model_dump_json())
 
         for type_name, messages in messages_by_type.items():
             file_path = airbyte_messages_dir / f"{type_name}.jsonl"
             file_path.write_text("\n".join(messages))
 
+        # Save configured catalog (input) if available
+        if self.configured_catalog is not None:
+            catalog_path = output_dir / "configured_catalog.json"
+            catalog_path.write_text(self.configured_catalog.model_dump_json(indent=2))
+            self.logger.info(f"Saved configured catalog to {catalog_path}")
+
         self.logger.info(f"Artifacts saved to {output_dir}")