airbyte-agent-mcp 0.1.30__py3-none-any.whl

airbyte_agent_mcp/secret_manager.py

@@ -0,0 +1,94 @@
+"""Secrets management with pluggable backends."""
+
+import os
+from abc import ABC, abstractmethod
+
+from dotenv import load_dotenv
+
+
+class SecretsBackend(ABC):
+    """Abstract base class for secrets backends."""
+
+    @abstractmethod
+    def get_secret(self, key: str) -> str | None:
+        """Get a secret value by key."""
+        pass
+
+
+class DotEnvSecretsBackend(SecretsBackend):
+    """Secrets backend that loads from .env file and environment variables."""
+
+    def __init__(self, dotenv_path: str = ".env"):
+        """Initialize backend.
+
+        Args:
+            dotenv_path: Path to .env file (default: ".env" in current directory)
+        """
+        self.dotenv_path = dotenv_path
+        self._cache: dict[str, str] = {}
+
+        # Load .env file if it exists
+        if os.path.exists(dotenv_path):
+            load_dotenv(dotenv_path, override=True)
+
+    def get_secret(self, key: str) -> str | None:
+        """Get secret from cache, then environment.
+
+        Args:
+            key: Secret key to look up
+
+        Returns:
+            Secret value or None if not found
+        """
+        # Check cache first
+        if key in self._cache:
+            return self._cache[key]
+
+        # Try environment variable
+        value = os.getenv(key)
+        if value is not None:
+            self._cache[key] = value
+            return value
+
+        return None
+
+
+class SecretsManager:
+    """Facade for managing secrets resolution."""
+
+    def __init__(self, backend: SecretsBackend):
+        """Initialize manager with a backend.
+
+        Args:
+            backend: Secrets backend implementation
+        """
+        self.backend = backend
+
+    def get_secrets(self, secret_mapping: dict[str, str]) -> dict[str, str]:
+        """Resolve multiple secrets from a mapping.
+
+        Args:
+            secret_mapping: Dict mapping param names to secret keys
+                Example: {"api_key": "STRIPE_API_KEY"}
+
+        Returns:
+            Dict mapping param names to secret values
+                Example: {"api_key": "sk_test_abc123"}
+
+        Raises:
+            ValueError: If any secret is not found
+        """
+        resolved = {}
+        missing = []
+
+        for param_name, secret_key in secret_mapping.items():
+            value = self.backend.get_secret(secret_key)
+            if value is None:
+                missing.append(secret_key)
+            else:
+                resolved[param_name] = value
+
+        if missing:
+            raise ValueError(f"Required secrets not found: {', '.join(missing)}. Check your .env file or environment variables.")
+
+        return resolved

airbyte_agent_mcp/server.py

@@ -0,0 +1,265 @@
+"""FastMCP server with connector tools."""
+
+import logging
+from typing import Any
+
+from fastmcp import FastMCP
+
+from airbyte_agent_mcp.config import load_connector_config, validate_connectors
+from airbyte_agent_mcp.connector_manager import ConnectorManager
+from airbyte_agent_mcp.models import ExecuteResponse, ListEntitiesResponse
+from airbyte_agent_mcp.secret_manager import DotEnvSecretsBackend, SecretsManager
+
+logger = logging.getLogger(__name__)
+
+# Initialize FastMCP server
+mcp = FastMCP("airbyte-agent-mcp")
+
+
+def _serialize_exception(e: Exception) -> dict:
+    """Serialize an exception to a JSON-safe dictionary.
+
+    Handles SDK exceptions that may contain non-serializable objects
+    like HTTPResponse in their __dict__.
+
+    Args:
+        e: The exception to serialize
+
+    Returns:
+        A JSON-serializable error dictionary
+    """
+    error_type = type(e).__name__
+
+    # Build error dict with safe, serializable values
+    error_dict: dict = {
+        "type": error_type,
+        "message": str(e),
+    }
+
+    # Extract useful fields from HTTP exceptions without including HTTPResponse objects
+    if hasattr(e, "status_code"):
+        error_dict["status_code"] = e.status_code
+
+    if hasattr(e, "retry_after") and e.retry_after is not None:
+        error_dict["retry_after"] = e.retry_after
+
+    if hasattr(e, "timeout_type") and e.timeout_type is not None:
+        error_dict["timeout_type"] = e.timeout_type
+
+    return error_dict
+
+
+@mcp.tool()
+async def execute(connector_id: str, entity: str, action: str, params: dict[str, Any] | None = None) -> dict:
+    """Execute an operation on a connector.
+
+    This is the primary tool for interacting with connectors. It creates a fresh
+    connector instance, executes the operation, and returns the result.
+
+    Args:
+        connector_id: Connector identifier from configured_connectors.yaml
+        entity: Entity name (e.g., "customers", "invoices"). The entity is not a URL path.
+        action: Operation action (e.g., "get", "list", "create", "update", "delete")
+        params: Operation parameters (optional, depends on action)
+            - For "get": {"id": "..."}
+            - For "list": {"limit": 10, "starting_after": "..."}
+            - For "create": {"field1": "value1", ...}
+
+    Returns:
+        Execution result with success status and data or error
+
+    Example:
+        execute(
+            connector_id="stripe",
+            entity="customers",
+            action="list",
+            params={"limit": 10}
+        )
+    """
+    params = params or {}
+
+    try:
+        logger.info(f"Tool call: execute({connector_id}, {entity}, {action})")
+
+        # Execute operation
+        result = await mcp.connector_manager.execute(
+            connector_id=connector_id,
+            entity=entity,
+            action=action,
+            params=params,
+        )
+
+        response = ExecuteResponse(
+            success=True,
+            data=result,
+            connector_id=connector_id,
+            entity=entity,
+            action=action,
+        )
+
+        return response.model_dump()
+
+    except Exception as e:
+        logger.error(f"Execution failed: {e}", exc_info=True)
+
+        response = ExecuteResponse(
+            success=False,
+            error=_serialize_exception(e),
+            connector_id=connector_id,
+            entity=entity,
+            action=action,
+        )
+
+        return response.model_dump()
+
+
+@mcp.tool()
+async def describe_connector(connector_id: str) -> dict:
+    """Describe a connector's available entities and operations.
+
+    Discovers what entities (data types) a connector provides and what
+    operations (actions) are available for each entity by parsing the
+    connector's OpenAPI specification.
+
+    Args:
+        connector_id: Connector identifier from configured_connectors.yaml
+
+    Returns:
+        Dictionary containing:
+        - connector_id: The connector identifier
+        - entities: List of entity objects, each with:
+          - entity_name: Entity identifier used in operations
+          - description: Entity description
+          - available_actions: List of supported operation actions
+
+    Example:
+        describe_connector(connector_id="stripe")
+
+        Returns:
+        {
+            "connector_id": "stripe",
+            "entities": [
+                {
+                    "entity_name": "customers",
+                    "description": "Customer objects",
+                    "available_actions": ["list", "retrieve"]
+                },
+                ...
+            ]
+        }
+    """
+    try:
+        logger.info(f"Tool call: describe_connector({connector_id})")
+
+        entities = await mcp.connector_manager.describe_connector(connector_id)
+
+        response = ListEntitiesResponse(connector_id=connector_id, entities=entities)
+
+        return response.model_dump()
+
+    except Exception as e:
+        logger.error(f"Failed to list entities: {e}", exc_info=True)
+        return {"error": str(e), "connector_id": connector_id}
+
+
+@mcp.tool()
+async def discover_connectors() -> dict:
+    """Discover all available configured connectors.
+
+    Returns a list of all connectors defined in the configured_connectors.yaml configuration
+    file. This allows you to see what connectors are available before executing
+    operations or describing their resources.
+
+    Returns:
+        Dictionary containing:
+        - connectors: List of connector objects, each with:
+          - id: Connector identifier used in other operations
+          - type: Connector type (local or remote)
+          - description: Human-readable description
+
+    Example:
+        discover_connectors()
+
+        Returns:
+        {
+            "connectors": [
+                {
+                    "id": "stripe",
+                    "type": "local",
+                    "description": "Stripe API connector"
+                },
+                {
+                    "id": "shopify",
+                    "type": "remote",
+                    "description": "Shopify connector from registry"
+                }
+            ]
+        }
+    """
+    try:
+        logger.info("Tool call: discover_connectors()")
+        return mcp.connector_manager.discover_connectors()
+
+    except Exception as e:
+        logger.error(f"Failed to discover connectors: {e}", exc_info=True)
+        return {"error": str(e), "connectors": []}
+
+
+def init_server(config_path: str = "configured_connectors.yaml", dotenv_path: str = ".env"):
+    """Initialize the MCP server with configuration.
+
+    Args:
+        config_path: Path to configured_connectors.yaml
+        dotenv_path: Path to .env file with secrets
+
+    Raises:
+        SystemExit: If initialization fails
+    """
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+    logger.info("Initializing airbyte-agent-mcp server...")
+
+    try:
+        # Load configuration
+        config = load_connector_config(config_path)
+        logger.info(f"Loaded configuration with {len(config.connectors)} connector(s)")
+
+        # Validate connectors
+        errors = validate_connectors(config)
+        if errors:
+            logger.error("Connector validation failed:")
+            for error in errors:
+                logger.error(f"  - {error}")
+            raise SystemExit(1)
+
+        # Initialize secrets manager
+        secrets_backend = DotEnvSecretsBackend(dotenv_path)
+        secrets_manager = SecretsManager(secrets_backend)
+        logger.info("Initialized secrets manager")
+
+        # Store managers on MCP instance (application-wide state)
+        mcp.connector_manager = ConnectorManager(config, secrets_manager)
+        logger.info("Initialized connector manager")
+
+        logger.info(" Server initialization complete")
+
+    except Exception as e:
+        logger.error(f"Failed to initialize server: {e}", exc_info=True)
+        raise SystemExit(1)
+
+
+def run_server(config_path: str = "configured_connectors.yaml", dotenv_path: str = ".env"):
+    """Run the MCP server.
+
+    Args:
+        config_path: Path to configured_connectors.yaml
+        dotenv_path: Path to .env file
+    """
+    init_server(config_path, dotenv_path)
+
+    # FastMCP handles the server loop
+    logger.info("Starting MCP server on stdio transport...")
+    mcp.run()

airbyte_agent_mcp-0.1.30.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: airbyte-agent-mcp
+Version: 0.1.30
+Summary: MCP server that exposes Airbyte Connector SDK as MCP tools
+Author-email: Airbyte Support <support@airbyte.io>
+Requires-Python: >=3.13
+Requires-Dist: click>=8.0.0
+Requires-Dist: fastmcp>=2.10.5
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: jinja2>=3.0.0
+Requires-Dist: jsonpath-ng>=1.6.1
+Requires-Dist: jsonref>=1.1.0
+Requires-Dist: jsonschema>=4.0.0
+Requires-Dist: opentelemetry-api>=1.37.0
+Requires-Dist: opentelemetry-sdk>=1.37.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: segment-analytics-python>=2.2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio<1.0.0,>=0.24.0; extra == 'dev'
+Requires-Dist: pytest<9.0.0,>=8.3.3; extra == 'dev'
+Requires-Dist: ruff==0.7.3; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Airbyte Agent MCP Server
+
+MCP server that exposes the Airbyte Connector SDK as Model Context Protocol tools.
+
+## Features
+
+- **Execute**: Run operations on any connector (primary tool)
+- **List Entities**: Discover available entities in a connector
+- **Describe Entity**: Get detailed schema for an entity
+- **Validate Operation**: Check parameters before execution
+
+## Configuration
+
+### 1. Create configured_connectors.yaml
+
+```yaml
+# Connector definitions
+connectors:
+  # Load connector from the Airbyte registry (recommended)
+  - id: stripe
+    type: local
+    connector_name: stripe
+    description: "My Stripe API connector"
+    secrets:
+      token: STRIPE_API_KEY
+```
+
+You can pin to a specific version from the registry:
+
+```yaml
+connectors:
+  - id: stripe
+    type: local
+    connector_name: stripe
+    version: 0.1.0
+    description: "Stripe connector pinned to v0.1.0"
+    secrets:
+      token: STRIPE_API_KEY
+```
+
+You can also load connectors from a local file path (version pinning not supported):
+
+```yaml
+connectors:
+  - id: my_api
+    type: local
+    path: ./connectors/my-api/connector.yaml
+    description: "My custom API connector"
+    secrets:
+      token: MY_API_KEY
+```
+
+See `configured_connectors.yaml.example` for more examples.
+
+### 2. Create .env file
+
+```bash
+STRIPE_API_KEY=sk_test_your_stripe_api_key_here
+```
+
+## Running
+
+```bash
+uv run airbyte_agent_mcp
+```
+
+The server also takes in args for specific paths to the configured_connectors.yaml file and the env file. With custom paths:
+
+```bash
+python -m airbyte_agent_mcp path/to/configured_connectors.yaml path/to/.env
+```
+
+The default paths are `./configured_connectors.yaml` and `./.env`
+
+## Usage with Claude Code
+
+Add to `~/.claude.json`:
+
+```json
+"mcpServers": {
+  "airbyte-agent-mcp": {
+    "type": "stdio",
+    "command": "uv",
+    "args": [
+      "--directory",
+      "/path/to/sonar/airbyte-agent-mcp",
+      "run",
+      "airbyte_agent_mcp"
+    ],
+    "env": {}
+  }
+},
+```
+
+## Development / Testing
+
+```bash
+# Install dev dependencies
+uv sync --all-extras
+
+# Run tests
+uv run pytest
+
+# Format code
+uv run ruff format .
+
+# Lint code
+uv run ruff check .
+```

airbyte_agent_mcp-0.1.30.dist-info/RECORD

@@ -0,0 +1,56 @@
+airbyte_agent_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+airbyte_agent_mcp/__main__.py,sha256=Ty8kXk2remMz6FFOnXTl5mg9mvOzI2JYYlu75z8hGXI,541
+airbyte_agent_mcp/config.py,sha256=Z3NeYC8Xi69M4J4ZbOaUhB-CSu9QuxNBuQZ87Ce5R9A,3172
+airbyte_agent_mcp/connector_manager.py,sha256=FLkN2AfBS6YDckokyPGwhcL_TwSIl-a93xN1o5Jv6oI,12931
+airbyte_agent_mcp/models.py,sha256=yTA9Syu_RVQbZT8CisIfSBpL0Iee4-qEmXQWxYgFjLg,5001
+airbyte_agent_mcp/registry_client.py,sha256=_boYT9ZzY8pAsb7LHTgOz7IHfhrbqKRQ_n-cTPDh4dE,3278
+airbyte_agent_mcp/secret_manager.py,sha256=BeDWcYX4d_SxtCBdNoaYarV39qCJBbZcqJcy3LUumDE,2600
+airbyte_agent_mcp/server.py,sha256=iYE4UJuSkaDgh5ph4cxFPVJ3mfgfB0_wq12uNDLB81w,8290
+airbyte_agent_mcp/_vendored/__init__.py,sha256=ILl7AHXMui__swyrjxrh9yRa4dLiwBvV6axPWFWty80,38
+airbyte_agent_mcp/_vendored/connector_sdk/__init__.py,sha256=T5o7roU6NSpH-lCAGZ338sE5dlh4ZU6i6IkeG1zpems,1949
+airbyte_agent_mcp/_vendored/connector_sdk/auth_strategies.py,sha256=0BfIISVzuvZTAYZjQFOOhKTpw0QuKDlLQBQ1PQo-V2M,39967
+airbyte_agent_mcp/_vendored/connector_sdk/auth_template.py,sha256=vKnyA21Jp33EuDjkIUAf1PGicwk4t9kZAPJuAgAZKzU,4458
+airbyte_agent_mcp/_vendored/connector_sdk/connector_model_loader.py,sha256=OEaXMI8lhjH-vAPfgaefrSijZJfttNqC6Ee3u2apYnA,33901
+airbyte_agent_mcp/_vendored/connector_sdk/constants.py,sha256=uH4rjBX6WsBP8M0jt7AUJI9w5Adn4wvJwib7Gdfkr1M,2736
+airbyte_agent_mcp/_vendored/connector_sdk/exceptions.py,sha256=ss5MGv9eVPmsbLcLWetuu3sDmvturwfo6Pw3M37Oq5k,481
+airbyte_agent_mcp/_vendored/connector_sdk/extensions.py,sha256=iWA2i0kiiGZY84H8P25A6QmfbuZwu7euMcj4-Vx2DOQ,20185
+airbyte_agent_mcp/_vendored/connector_sdk/http_client.py,sha256=Uv86Hye3uIs2F4TbXXFWnB4E6BHfvJQLBwak7J1_0kw,27073
+airbyte_agent_mcp/_vendored/connector_sdk/secrets.py,sha256=UWcO9fP-vZwcfkAuvlZahlOCTOwdNN860BIwe8X4jxw,6868
+airbyte_agent_mcp/_vendored/connector_sdk/types.py,sha256=1yz4O8wjL5Aytzz0duluxJZ7ntEFIBlA4_6XSAlizpE,8079
+airbyte_agent_mcp/_vendored/connector_sdk/utils.py,sha256=G4LUXOC2HzPoND2v4tQW68R9uuPX9NQyCjaGxb7Kpl0,1958
+airbyte_agent_mcp/_vendored/connector_sdk/validation.py,sha256=CDjCux1eg35a0Y4BegSivzIwZjiTqOxYWotWNLqTSVU,31792
+airbyte_agent_mcp/_vendored/connector_sdk/executor/__init__.py,sha256=EmG9YQNAjSuYCVB4D5VoLm4qpD1KfeiiOf7bpALj8p8,702
+airbyte_agent_mcp/_vendored/connector_sdk/executor/hosted_executor.py,sha256=FXlV4JgYbYMHVHMbeMH8LOdhsXuw-flEJjHXf7JmMtc,6756
+airbyte_agent_mcp/_vendored/connector_sdk/executor/local_executor.py,sha256=hHlBTtvykrUcfypzyW0e61fU4e3vlxc90mypCFzgSl0,61879
+airbyte_agent_mcp/_vendored/connector_sdk/executor/models.py,sha256=lYVT_bNcw-PoIks4WHNyl2VY-lJVf2FntzINSOBIheE,5845
+airbyte_agent_mcp/_vendored/connector_sdk/http/__init__.py,sha256=y8fbzZn-3yV9OxtYz8Dy6FFGI5v6TOqADd1G3xHH3Hw,911
+airbyte_agent_mcp/_vendored/connector_sdk/http/config.py,sha256=6J7YIIwHC6sRu9i-yKa5XvArwK2KU60rlnmxzDZq3lw,3283
+airbyte_agent_mcp/_vendored/connector_sdk/http/exceptions.py,sha256=eYdYmxqcwA6pgrSoRXNfR6_nRBGRH6upp2-r1jcKaZo,3586
+airbyte_agent_mcp/_vendored/connector_sdk/http/protocols.py,sha256=eV7NbBIQOcPLw-iu8mtkV2zCVgScDwP0ek1SbPNQo0g,3323
+airbyte_agent_mcp/_vendored/connector_sdk/http/response.py,sha256=r7QFYRkw6is-Na7WozAyzZynpCQ90RBUhnX4pBSJ1Yc,3338
+airbyte_agent_mcp/_vendored/connector_sdk/http/adapters/__init__.py,sha256=gjbWdU4LfzUG2PETI0TkfkukdzoCAhpL6FZtIEnkO-s,209
+airbyte_agent_mcp/_vendored/connector_sdk/http/adapters/httpx_adapter.py,sha256=dkYhzBWiKBmzWZlc-cRTx50Hb6fy3OI8kOQvXRfS1CQ,8465
+airbyte_agent_mcp/_vendored/connector_sdk/logging/__init__.py,sha256=IZoE5yXhwSA0m3xQqh0FiCifjp1sB3S8jnnFPuJLYf8,227
+airbyte_agent_mcp/_vendored/connector_sdk/logging/logger.py,sha256=Nh0h3C0aO-rAqZhDIyeEXG6Jd7yj1Gk32ECMPth0wl8,8118
+airbyte_agent_mcp/_vendored/connector_sdk/logging/types.py,sha256=iI-xLoOg33OUGQOp3CeaxKtHh73WXE-oul6ZCNf3Nzc,3209
+airbyte_agent_mcp/_vendored/connector_sdk/observability/__init__.py,sha256=ojx1n9vaWCXFFvb3-90Pwtg845trFdV2v6wcCoO75Ko,269
+airbyte_agent_mcp/_vendored/connector_sdk/observability/models.py,sha256=rF6-SoAAywqL8bhEv7yCbmr_W_w0vmApO-MCxcHq9RI,473
+airbyte_agent_mcp/_vendored/connector_sdk/observability/redactor.py,sha256=HRbSwGxsfQYbYlG4QBVvv8Qnw0d4SMowMv0dTFHsHqQ,2361
+airbyte_agent_mcp/_vendored/connector_sdk/observability/session.py,sha256=fLBgb9olATdoC0IMtd8MKe581t1HuK73MiGbghPzUHQ,3083
+airbyte_agent_mcp/_vendored/connector_sdk/performance/__init__.py,sha256=Sp5fSd1LvtIQkv-fnrKqPsM7-6IWp0sSZSK0mhzal_A,200
+airbyte_agent_mcp/_vendored/connector_sdk/performance/instrumentation.py,sha256=_dXvNiqdndIBwDjeDKNViWzn_M5FkSUsMmJtFldrmsM,1504
+airbyte_agent_mcp/_vendored/connector_sdk/performance/metrics.py,sha256=3-wPwlJyfVLUIG3y7ESxk0avhkILk3z8K7zSrnlZf5U,2833
+airbyte_agent_mcp/_vendored/connector_sdk/schema/__init__.py,sha256=Uymu-QuzGJuMxexBagIvUxpVAigIuIhz3KeBl_Vu4Ko,1638
+airbyte_agent_mcp/_vendored/connector_sdk/schema/base.py,sha256=le4UqbUrPFtWxIwmoTAyS0chYFO5ksEMYDyrkK5ORlI,4776
+airbyte_agent_mcp/_vendored/connector_sdk/schema/components.py,sha256=2ivMNhUAcovw88qvDkW221ILf1L63eXteztTDZL46us,7989
+airbyte_agent_mcp/_vendored/connector_sdk/schema/connector.py,sha256=VFBOzIkLgYBR1XUTmyrPGqBkX8PP-zsG8avQcdJUqXs,3864
+airbyte_agent_mcp/_vendored/connector_sdk/schema/extensions.py,sha256=LdoCuMLNdCj68O47qAL4v8xmqGz5tJgRiNZL5JnL9uw,3311
+airbyte_agent_mcp/_vendored/connector_sdk/schema/operations.py,sha256=zInMjx9iOEVZo-CCWw06Uk2SFg7HtUAXXpO5kFGUwNk,5825
+airbyte_agent_mcp/_vendored/connector_sdk/schema/security.py,sha256=Jtrhb58d1zssN5yR7LhLJi-QK0PsZKT7uIvPqanF0co,8114
+airbyte_agent_mcp/_vendored/connector_sdk/telemetry/__init__.py,sha256=RaLgkBU4dfxn1LC5Y0Q9rr2PJbrwjxvPgBLmq8_WafE,211
+airbyte_agent_mcp/_vendored/connector_sdk/telemetry/config.py,sha256=tLmQwAFD0kP1WyBGWBS3ysaudN9H3e-3EopKZi6cGKg,885
+airbyte_agent_mcp/_vendored/connector_sdk/telemetry/events.py,sha256=NvqjlUbkm6cbGh4ffKxYxtjdwwgzfPF4MKJ2GfgWeFg,1285
+airbyte_agent_mcp/_vendored/connector_sdk/telemetry/tracker.py,sha256=KacNdbHatvPPhnNrycp5YUuD5xpkp56AFcHd-zguBgk,5247
+airbyte_agent_mcp-0.1.30.dist-info/METADATA,sha256=s8S_NKeiCnFDPz5m-BExQbyapXVoEQzuxEBlGhWMA5o,3009
+airbyte_agent_mcp-0.1.30.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+airbyte_agent_mcp-0.1.30.dist-info/RECORD,,

airbyte_agent_mcp-0.1.30.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any