airbyte-agent-greenhouse 0.17.48__py3-none-any.whl

airbyte_agent_greenhouse/_vendored/connector_sdk/secrets.py

@@ -0,0 +1,182 @@
+"""Secret handling utilities for the Airbyte SDK.
+
+This module provides utilities for handling sensitive data like API keys, tokens,
+and passwords. It uses Pydantic's SecretStr to ensure secrets are obfuscated in
+logs, error messages, and string representations.
+
+Example:
+    >>> from .secrets import SecretStr
+    >>> api_key = SecretStr("my-secret-key")
+    >>> print(api_key)  # Outputs: **********
+    >>> print(repr(api_key))  # Outputs: SecretStr('**********')
+    >>> api_key.get_secret_value()  # Returns: 'my-secret-key'
+"""
+
+import os
+import re
+from typing import Any, Dict
+
+from pydantic import SecretStr
+
+__all__ = [
+    "SecretStr",
+    "convert_to_secret_dict",
+    "get_secret_values",
+    "resolve_env_var_references",
+]
+
+
+def convert_to_secret_dict(secrets: Dict[str, str]) -> Dict[str, SecretStr]:
+    """Convert a dictionary of plain string secrets to SecretStr values.
+
+    Args:
+        secrets: Dictionary with string keys and plain string secret values
+
+    Returns:
+        Dictionary with string keys and SecretStr values
+
+    Example:
+        >>> plain_secrets = {"api_key": "secret123", "token": "token456"}
+        >>> secret_dict = convert_to_secret_dict(plain_secrets)
+        >>> print(secret_dict["api_key"])  # Outputs: **********
+    """
+    return {key: SecretStr(value) for key, value in secrets.items()}
+
+
+def get_secret_values(secrets: Dict[str, SecretStr]) -> Dict[str, str]:
+    """Extract plain string values from a dictionary of SecretStr values.
+
+    Args:
+        secrets: Dictionary with string keys and SecretStr values
+
+    Returns:
+        Dictionary with string keys and plain string values
+
+    Warning:
+        Use with caution. This exposes the actual secret values.
+
+    Example:
+        >>> secret_dict = {"api_key": SecretStr("secret123")}
+        >>> plain_dict = get_secret_values(secret_dict)
+        >>> print(plain_dict["api_key"])  # Outputs: secret123
+    """
+    return {key: value.get_secret_value() for key, value in secrets.items()}
+
+
+class SecretResolutionError(Exception):
+    """Raised when environment variable resolution fails."""
+
+    pass
+
+
+def resolve_env_var_references(
+    secret_mappings: Dict[str, Any],
+    strict: bool = True,
+    env_vars: Dict[str, str] | None = None,
+) -> Dict[str, str]:
+    """Resolve environment variable references in secret values.
+
+    This function processes a dictionary of secret mappings and resolves any
+    environment variable references using the ${ENV_VAR_NAME} syntax. All
+    environment variable references in the values will be replaced with their
+    actual values from the provided environment variable map or os.environ.
+
+    Args:
+        secret_mappings: Dictionary mapping secret keys to values that may contain
+                        environment variable references (e.g., {"token": "${API_KEY}"})
+        strict: If True, raises SecretResolutionError when a referenced environment
+               variable is not found. If False, leaves unresolved references as-is.
+        env_vars: Optional dictionary of environment variables to use for resolution.
+                 If None, uses os.environ.
+
+    Returns:
+        Dictionary with the same keys but environment variable references resolved
+        to their actual values as plain strings
+
+    Raises:
+        SecretResolutionError: When strict=True and a referenced environment variable
+                              is not found or is empty
+        ValueError: When an environment variable name doesn't match valid naming
+                   conventions (must start with letter or underscore, followed by
+                   alphanumeric characters or underscores)
+
+    Example:
+        >>> import os
+        >>> os.environ["MY_TOKEN"] = "secret_value_123"
+        >>> mappings = {"token": "${MY_TOKEN}", "literal": "plain_value"}
+        >>> resolved = resolve_env_var_references(mappings)
+        >>> print(resolved)
+        {'token': 'secret_value_123', 'literal': 'plain_value'}
+
+        >>> # Using custom env_vars dict
+        >>> custom_env = {"CUSTOM_TOKEN": "my_secret"}
+        >>> mappings = {"token": "${CUSTOM_TOKEN}"}
+        >>> resolved = resolve_env_var_references(mappings, env_vars=custom_env)
+        >>> print(resolved)
+        {'token': 'my_secret'}
+
+        >>> # Multiple references in one value
+        >>> mappings = {"combined": "${PREFIX}_${SUFFIX}"}
+        >>> os.environ["PREFIX"] = "api"
+        >>> os.environ["SUFFIX"] = "key"
+        >>> resolved = resolve_env_var_references(mappings)
+        >>> print(resolved["combined"])
+        'api_key'
+
+        >>> # Missing variable with strict=True (raises error)
+        >>> try:
+        ...     resolve_env_var_references({"token": "${MISSING_VAR}"})
+        ... except SecretResolutionError as e:
+        ...     print(f"Error: {e}")
+        Error: Environment variable 'MISSING_VAR' not found or empty
+
+        >>> # Missing variable with strict=False (keeps reference)
+        >>> resolved = resolve_env_var_references(
+        ...     {"token": "${MISSING_VAR}"},
+        ...     strict=False
+        ... )
+        >>> print(resolved["token"])
+        ${MISSING_VAR}
+    """
+    resolved = {}
+
+    # Use provided env_vars or default to os.environ
+    env_source = env_vars if env_vars is not None else os.environ
+
+    # Environment variable name pattern: starts with letter or underscore,
+    # followed by alphanumeric or underscores
+    env_var_pattern = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}")
+
+    for key, value in secret_mappings.items():
+        if isinstance(value, str):
+
+            def replacer(match: re.Match) -> str:
+                """Replace a single ${ENV_VAR} reference with its value."""
+                env_var_name = match.group(1)
+
+                # Validate environment variable name format
+                if not re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", env_var_name):
+                    raise ValueError(
+                        f"Invalid environment variable name: '{env_var_name}'. "
+                        "Must start with a letter or underscore, followed by "
+                        "alphanumeric characters or underscores."
+                    )
+
+                env_value = env_source.get(env_var_name)
+
+                if env_value is None or env_value == "":
+                    if strict:
+                        raise SecretResolutionError(f"Environment variable '{env_var_name}' not found or empty")
+                    # In non-strict mode, keep the original reference
+                    return match.group(0)
+
+                return env_value
+
+            # Replace all ${ENV_VAR} references in the value
+            resolved_value = env_var_pattern.sub(replacer, value)
+            resolved[key] = resolved_value
+        else:
+            # Non-string values are converted to strings
+            resolved[key] = str(value)
+
+    return resolved

airbyte_agent_greenhouse/_vendored/connector_sdk/telemetry/__init__.py

@@ -0,0 +1,10 @@
+"""Telemetry tracking for Airbyte SDK."""
+
+from .config import TelemetryConfig, TelemetryMode
+from .tracker import SegmentTracker
+
+__all__ = [
+    "TelemetryConfig",
+    "TelemetryMode",
+    "SegmentTracker",
+]

airbyte_agent_greenhouse/_vendored/connector_sdk/telemetry/config.py

@@ -0,0 +1,32 @@
+"""Telemetry configuration from environment variables."""
+
+import os
+from enum import Enum
+
+# Hardcoded Segment write key for Airbyte telemetry
+SEGMENT_WRITE_KEY = "sFM7q98HtHTMmCW3d6nsPWYCIdrbs7gq"
+
+
+class TelemetryMode(Enum):
+    """Telemetry tracking modes."""
+
+    BASIC = "basic"
+    DISABLED = "disabled"
+
+
+class TelemetryConfig:
+    """Telemetry configuration from environment variables."""
+
+    @staticmethod
+    def get_mode() -> TelemetryMode:
+        """Get telemetry mode from environment variable."""
+        mode_str = os.getenv("AIRBYTE_TELEMETRY_MODE", "basic").lower()
+        try:
+            return TelemetryMode(mode_str)
+        except ValueError:
+            return TelemetryMode.BASIC
+
+    @staticmethod
+    def is_enabled() -> bool:
+        """Telemetry is enabled if mode is not disabled."""
+        return TelemetryConfig.get_mode() != TelemetryMode.DISABLED

airbyte_agent_greenhouse/_vendored/connector_sdk/telemetry/events.py

@@ -0,0 +1,59 @@
+"""Telemetry event models."""
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from typing import Any, Dict
+
+
+@dataclass
+class BaseEvent:
+    """Base class for all telemetry events."""
+
+    timestamp: datetime
+    session_id: str
+    user_id: str
+    execution_context: str
+    is_internal_user: bool = field(default=False, kw_only=True)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert event to dictionary with ISO formatted timestamp."""
+        data = asdict(self)
+        data["timestamp"] = self.timestamp.isoformat()
+        return data
+
+
+@dataclass
+class ConnectorInitEvent(BaseEvent):
+    """Connector initialization event."""
+
+    connector_name: str
+    python_version: str
+    os_name: str
+    os_version: str
+    public_ip: str | None = None
+    connector_version: str | None = None
+
+
+@dataclass
+class OperationEvent(BaseEvent):
+    """API operation event."""
+
+    connector_name: str
+    entity: str
+    action: str
+    timing_ms: float
+    public_ip: str | None = None
+    status_code: int | None = None
+    error_type: str | None = None
+
+
+@dataclass
+class SessionEndEvent(BaseEvent):
+    """Session end event."""
+
+    connector_name: str
+    duration_seconds: float
+    operation_count: int
+    success_count: int
+    failure_count: int
+    public_ip: str | None = None

airbyte_agent_greenhouse/_vendored/connector_sdk/telemetry/tracker.py

@@ -0,0 +1,155 @@
+"""Anonymous telemetry tracker using Segment."""
+
+import logging
+import platform
+import sys
+from datetime import datetime
+
+from ..observability import ObservabilitySession
+
+from .config import SEGMENT_WRITE_KEY, TelemetryConfig, TelemetryMode
+from .events import ConnectorInitEvent, OperationEvent, SessionEndEvent
+
+logger = logging.getLogger(__name__)
+
+
+class SegmentTracker:
+    """Anonymous telemetry tracker using Segment."""
+
+    def __init__(
+        self,
+        session: ObservabilitySession,
+        mode: TelemetryMode | None = None,
+    ):
+        self.session = session
+        self.mode = mode or TelemetryConfig.get_mode()
+        self.success_count = 0
+        self.failure_count = 0
+        self.enabled = TelemetryConfig.is_enabled()
+        self._analytics = None
+
+        if self.enabled:
+            try:
+                # NOTE: Import here intentionally - segment is an optional dependency.
+                # This allows the SDK to work without telemetry if segment is not installed.
+                import segment.analytics as analytics
+
+                analytics.write_key = SEGMENT_WRITE_KEY
+                self._analytics = analytics
+                self._log_startup_message()
+            except ImportError:
+                logger.warning("Telemetry disabled: segment-analytics-python not installed")
+                self.enabled = False
+
+    def _log_startup_message(self):
+        """Log message when telemetry is enabled."""
+        logger.info(f"Anonymous telemetry enabled (mode: {self.mode.value})")
+        logger.info("To opt-out: export AIRBYTE_TELEMETRY_MODE=disabled")
+
+    def track_connector_init(
+        self,
+        connector_version: str | None = None,
+    ) -> None:
+        """Track connector initialization."""
+        if not self.enabled or not self._analytics:
+            return
+
+        try:
+            event = ConnectorInitEvent(
+                timestamp=datetime.utcnow(),
+                session_id=self.session.session_id,
+                user_id=self.session.user_id,
+                execution_context=self.session.execution_context,
+                is_internal_user=self.session.is_internal_user,
+                public_ip=self.session.public_ip,
+                connector_name=self.session.connector_name,
+                connector_version=connector_version,
+                python_version=f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+                os_name=platform.system(),
+                os_version=platform.release(),
+            )
+
+            self._analytics.track(
+                user_id=self.session.user_id,
+                anonymous_id=event.session_id,
+                event="Connector Initialized",
+                properties=event.to_dict(),
+            )
+        except Exception as e:
+            # Never fail on tracking errors
+            logger.error(f"Telemetry error: {e}")
+
+    def track_operation(
+        self,
+        entity: str,
+        action: str,
+        status_code: int | None,
+        timing_ms: float,
+        error_type: str | None = None,
+    ) -> None:
+        """Track API operation."""
+        # Always track success/failure counts (useful even when tracking is disabled)
+        if status_code and 200 <= status_code < 300:
+            self.success_count += 1
+        else:
+            self.failure_count += 1
+
+        if not self.enabled or not self._analytics:
+            return
+
+        try:
+            event = OperationEvent(
+                timestamp=datetime.utcnow(),
+                session_id=self.session.session_id,
+                user_id=self.session.user_id,
+                execution_context=self.session.execution_context,
+                is_internal_user=self.session.is_internal_user,
+                public_ip=self.session.public_ip,
+                connector_name=self.session.connector_name,
+                entity=entity,
+                action=action,
+                status_code=status_code,
+                timing_ms=timing_ms,
+                error_type=error_type,
+            )
+
+            self._analytics.track(
+                user_id=self.session.user_id,
+                anonymous_id=event.session_id,
+                event="Operation Executed",
+                properties=event.to_dict(),
+            )
+        except Exception as e:
+            logger.error(f"Telemetry error: {e}")
+
+    def track_session_end(self) -> None:
+        """Track session end."""
+        if not self.enabled or not self._analytics:
+            return
+
+        try:
+            event = SessionEndEvent(
+                timestamp=datetime.utcnow(),
+                session_id=self.session.session_id,
+                user_id=self.session.user_id,
+                execution_context=self.session.execution_context,
+                is_internal_user=self.session.is_internal_user,
+                public_ip=self.session.public_ip,
+                connector_name=self.session.connector_name,
+                duration_seconds=self.session.duration_seconds(),
+                operation_count=self.session.operation_count,
+                success_count=self.success_count,
+                failure_count=self.failure_count,
+            )
+
+            self._analytics.track(
+                user_id=self.session.user_id,
+                anonymous_id=event.session_id,
+                event="Session Ended",
+                properties=event.to_dict(),
+            )
+
+            # Ensure events are sent before shutdown
+            self._analytics.flush()
+        except Exception as e:
+            logger.error(f"Telemetry error: {e}")

airbyte_agent_greenhouse/_vendored/connector_sdk/types.py

@@ -0,0 +1,245 @@
+"""Type definitions for Airbyte SDK."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .constants import OPENAPI_DEFAULT_VERSION
+from .schema.components import PathOverrideConfig
+from .schema.extensions import RetryConfig
+from .schema.security import AirbyteAuthConfig
+
+
+class Action(str, Enum):
+    """Supported actions for Entity operations."""
+
+    GET = "get"
+    CREATE = "create"
+    UPDATE = "update"
+    DELETE = "delete"
+    LIST = "list"
+    API_SEARCH = "api_search"
+    DOWNLOAD = "download"
+    AUTHORIZE = "authorize"
+
+
+class AuthType(str, Enum):
+    """Supported authentication types."""
+
+    API_KEY = "api_key"
+    BEARER = "bearer"
+    HTTP = "http"
+    BASIC = "basic"
+    OAUTH2 = "oauth2"
+
+
+class ContentType(str, Enum):
+    """Supported content types for request bodies."""
+
+    JSON = "application/json"
+    FORM_URLENCODED = "application/x-www-form-urlencoded"
+    FORM_DATA = "multipart/form-data"
+
+
+class ParameterLocation(str, Enum):
+    """Location of operation parameters."""
+
+    PATH = "path"
+    QUERY = "query"
+    HEADER = "header"
+    COOKIE = "cookie"
+
+
+# All comprehensive OpenAPI 3.0 models are now in connector_sdk.schema package
+# Import from connector_sdk.schema for: OpenAPIConnector, Components, Schema, Operation, etc.
+
+
+class AuthOption(BaseModel):
+    """A single authentication option in a multi-auth connector.
+
+    Represents one security scheme from OpenAPI components.securitySchemes.
+    Each option defines a complete authentication method with its own type,
+    configuration, and user-facing credential specification.
+
+    Example:
+        For a connector supporting both OAuth2 and API Key auth:
+        - AuthOption(scheme_name="oauth", type=OAUTH2, ...)
+        - AuthOption(scheme_name="apikey", type=BEARER, ...)
+    """
+
+    scheme_name: str = Field(description="Security scheme name from OpenAPI spec (e.g., 'githubOAuth', 'githubPAT')")
+    type: AuthType = Field(description="Authentication type for this option")
+    config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Auth-specific configuration (e.g., OAuth2 refresh settings)",
+    )
+    user_config_spec: AirbyteAuthConfig | None = Field(
+        None,
+        description="User-facing credential specification from x-airbyte-auth-config",
+    )
+
+
+class AuthConfig(BaseModel):
+    """Authentication configuration supporting single or multiple auth methods.
+
+    Connectors can define either:
+    - Single auth: One authentication method (backwards compatible)
+    - Multi-auth: Multiple authentication methods (user/agent selects one)
+
+    For single-auth connectors (most common):
+        AuthConfig(type=OAUTH2, config={...}, user_config_spec={...})
+
+    For multi-auth connectors:
+        AuthConfig(options=[
+            AuthOption(scheme_name="oauth", type=OAUTH2, ...),
+            AuthOption(scheme_name="apikey", type=BEARER, ...)
+        ])
+    """
+
+    # Single-auth mode (backwards compatible)
+    type: AuthType | None = Field(
+        None,
+        description="Authentication type (single-auth mode only)",
+    )
+    config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Auth configuration (single-auth mode only)",
+    )
+    user_config_spec: AirbyteAuthConfig | None = Field(
+        None,
+        description="User-facing config spec from x-airbyte-auth-config (single-auth mode)",
+    )
+
+    # Multi-auth mode
+    options: list[AuthOption] | None = Field(
+        None,
+        description="Multiple authentication options (multi-auth mode only)",
+    )
+
+    def is_multi_auth(self) -> bool:
+        """Check if this configuration supports multiple authentication methods.
+
+        Returns:
+            True if multiple auth options are available, False for single-auth
+        """
+        return self.options is not None and len(self.options) > 0
+
+    def get_single_option(self) -> AuthOption:
+        """Get single auth option (for backwards compatibility).
+
+        Converts single-auth config to AuthOption format for uniform handling.
+
+        Returns:
+            AuthOption containing the single auth configuration
+
+        Raises:
+            ValueError: If this is a multi-auth config or invalid
+        """
+        if self.is_multi_auth():
+            raise ValueError("Cannot call get_single_option() on multi-auth config. Use options list instead.")
+
+        if self.type is None:
+            raise ValueError("Invalid AuthConfig: neither single-auth nor multi-auth")
+
+        return AuthOption(
+            scheme_name="default",
+            type=self.type,
+            config=self.config,
+            user_config_spec=self.user_config_spec,
+        )
+
+
+# Executor types (used by executor.py)
+class EndpointDefinition(BaseModel):
+    """Definition of an API endpoint."""
+
+    method: str  # GET, POST, PUT, DELETE, etc.
+    path: str  # e.g., /v1/customers/{id} (OpenAPI path)
+    path_override: PathOverrideConfig | None = Field(
+        None,
+        description=("Path override config from x-airbyte-path-override. When set, overrides the path for actual HTTP requests."),
+    )
+    action: Action | None = None  # Semantic action (get, list, create, update, delete)
+    description: str | None = None
+    body_fields: list[str] = Field(default_factory=list)  # For POST/PUT
+    query_params: list[str] = Field(default_factory=list)  # For GET
+    query_params_schema: dict[str, dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Schema for query params including defaults: {name: {type, default, required}}",
+    )
+    deep_object_params: list[str] = Field(
+        default_factory=list,
+        description="Query parameters using deepObject style (e.g., filter[key]=value)",
+    )  # For GET with deepObject query params
+    path_params: list[str] = Field(default_factory=list)  # Extracted from path
+    path_params_schema: dict[str, dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Schema for path params including defaults: {name: {type, default, required}}",
+    )
+    content_type: ContentType = ContentType.JSON
+    request_schema: dict[str, Any] | None = None
+    response_schema: dict[str, Any] | None = None
+
+    # GraphQL support (Airbyte extension)
+    graphql_body: dict[str, Any] | None = Field(
+        None,
+        description="GraphQL body configuration from x-airbyte-body-type extension",
+    )
+
+    # Record extractor support (Airbyte extension)
+    record_extractor: str | None = Field(
+        None,
+        description="JSONPath expression to extract records from response envelopes",
+    )
+
+    # Metadata extractor support (Airbyte extension)
+    meta_extractor: dict[str, str] | None = Field(
+        None,
+        description="Dictionary mapping field names to JSONPath expressions for extracting metadata from response envelopes",
+    )
+
+    # Download support (Airbyte extension)
+    file_field: str | None = Field(
+        None,
+        description="Field in metadata response containing download URL (from x-airbyte-file-url extension)",
+    )
+
+    # Test validation support (Airbyte extension)
+    untested: bool = Field(
+        False,
+        description="Mark operation as untested to skip cassette validation (from x-airbyte-untested extension)",
+    )
+
+
+class EntityDefinition(BaseModel):
+    """Definition of an API entity."""
+
+    model_config = {"populate_by_name": True}
+
+    name: str
+    stream_name: str | None = Field(
+        default=None,
+        description="Airbyte stream name for cache lookup (from x-airbyte-stream-name schema extension)",
+    )
+    actions: list[Action]
+    endpoints: dict[Action, EndpointDefinition]
+    entity_schema: dict[str, Any] | None = Field(default=None, alias="schema")
+
+
+class ConnectorModel(BaseModel):
+    """Complete connector model loaded from YAML definition."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    id: UUID
+    name: str
+    version: str = OPENAPI_DEFAULT_VERSION
+    base_url: str
+    auth: AuthConfig
+    entities: list[EntityDefinition]
+    openapi_spec: Any | None = None  # Optional reference to OpenAPIConnector
+    retry_config: RetryConfig | None = None  # Optional retry configuration