airbyte-agent-slack 0.1.33__tar.gz → 0.1.38__tar.gz

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Slack changelog
 
+## [0.1.38] - 2026-01-30
+- Updated connector definition (YAML version 0.1.12)
+- Source commit: 40765c71
+- SDK version: 0.1.0
+
+## [0.1.37] - 2026-01-30
+- Updated connector definition (YAML version 0.1.11)
+- Source commit: 5f65d643
+- SDK version: 0.1.0
+
+## [0.1.36] - 2026-01-30
+- Updated connector definition (YAML version 0.1.10)
+- Source commit: 5b20f488
+- SDK version: 0.1.0
+
+## [0.1.35] - 2026-01-30
+- Updated connector definition (YAML version 0.1.10)
+- Source commit: a3729d85
+- SDK version: 0.1.0
+
+## [0.1.34] - 2026-01-29
+- Updated connector definition (YAML version 0.1.10)
+- Source commit: 43200eed
+- SDK version: 0.1.0
+
 ## [0.1.33] - 2026-01-29
 - Updated connector definition (YAML version 0.1.10)
 - Source commit: c718c683

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-agent-slack
-Version: 0.1.33
+Version: 0.1.38
 Summary: Airbyte Slack Connector for AI platforms
 Project-URL: Homepage, https://github.com/airbytehq/airbyte-agent-connectors
 Project-URL: Documentation, https://docs.airbyte.com/ai-agents/
@@ -158,6 +158,7 @@ See the official [Slack API reference](https://api.slack.com/methods).
 
 ## Version information
 
-- **Package version:** 0.1.33
-- **Connector version:** 0.1.10
-- **Generated with Connector SDK commit SHA:** c718c683a61ee72524442b7fd5e9ac3a1b94698c
+- **Package version:** 0.1.38
+- **Connector version:** 0.1.12
+- **Generated with Connector SDK commit SHA:** 40765c717093dffed8c5e9ed8d5b3a6fbbe9b181
+- **Changelog:** [View changelog](https://github.com/airbytehq/airbyte-agent-connectors/blob/main/connectors/slack/CHANGELOG.md)

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/README.md

@@ -125,6 +125,7 @@ See the official [Slack API reference](https://api.slack.com/methods).
 
 ## Version information
 
-- **Package version:** 0.1.33
-- **Connector version:** 0.1.10
-- **Generated with Connector SDK commit SHA:** c718c683a61ee72524442b7fd5e9ac3a1b94698c
+- **Package version:** 0.1.38
+- **Connector version:** 0.1.12
+- **Generated with Connector SDK commit SHA:** 40765c717093dffed8c5e9ed8d5b3a6fbbe9b181
+- **Changelog:** [View changelog](https://github.com/airbytehq/airbyte-agent-connectors/blob/main/connectors/slack/CHANGELOG.md)

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/__init__.py

@@ -18,8 +18,8 @@ from .models import (
     ChannelsListResponse,
     ChannelResponse,
     Reaction,
-    File,
     Attachment,
+    File,
     Message,
     Thread,
     EditedInfo,
@@ -97,8 +97,8 @@ __all__ = [
     "ChannelsListResponse",
     "ChannelResponse",
     "Reaction",
-    "File",
     "Attachment",
+    "File",
     "Message",
     "Thread",
     "EditedInfo",

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/_vendored/connector_sdk/connector_model_loader.py

@@ -1014,6 +1014,7 @@ def _parse_security_scheme_to_option(scheme_name: str, scheme: Any) -> AuthOptio
         type=single_auth.type,
         config=single_auth.config,
         user_config_spec=single_auth.user_config_spec,
+        untested=getattr(scheme, "x_airbyte_untested", False),
     )
 
 

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/_vendored/connector_sdk/executor/local_executor.py

@@ -36,6 +36,7 @@ from ..types import (
     EndpointDefinition,
     EntityDefinition,
 )
+from ..utils import find_matching_auth_options
 
 from .models import (
     ActionNotSupportedError,
@@ -356,8 +357,8 @@ class LocalExecutor:
     ) -> tuple[AuthOption, dict[str, SecretStr]]:
         """Infer authentication scheme from provided credentials.
 
-        Matches user credentials against each auth option's required fields
-        to determine which scheme to use.
+        Uses shared utility find_matching_auth_options to match credentials
+        against each auth option's required fields.
 
         Args:
             user_credentials: User-provided credentials
@@ -375,16 +376,8 @@ class LocalExecutor:
         # Get the credential keys provided by the user
         provided_keys = set(user_credentials.keys())
 
-        # Find all options where all required fields are present
-        matching_options: list[AuthOption] = []
-        for option in options:
-            if option.user_config_spec and option.user_config_spec.required:
-                required_fields = set(option.user_config_spec.required)
-                if required_fields.issubset(provided_keys):
-                    matching_options.append(option)
-            elif not option.user_config_spec or not option.user_config_spec.required:
-                # Option has no required fields - it matches any credentials
-                matching_options.append(option)
+        # Use shared utility to find matching options
+        matching_options = find_matching_auth_options(provided_keys, options)
 
         # Handle matching results
         if len(matching_options) == 0:
@@ -584,7 +577,7 @@ class LocalExecutor:
             return ExecutionResult(
                 success=True,
                 data={
-                    "status": "unhealthy",
+                    "status": "skipped",
                     "error": "No list operation available for health check",
                 },
             )
@@ -599,7 +592,7 @@ class LocalExecutor:
             return ExecutionResult(
                 success=True,
                 data={
-                    "status": "unhealthy",
+                    "status": "skipped",
                     "error": "No standard handler available",
                 },
             )
@@ -616,13 +609,14 @@ class LocalExecutor:
             )
         except Exception as e:
             return ExecutionResult(
-                success=True,
+                success=False,
                 data={
                     "status": "unhealthy",
                     "error": str(e),
                     "checked_entity": check_entity,
                     "checked_action": "list",
                 },
+                error=str(e),
             )
 
     async def _execute_operation(

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/_vendored/connector_sdk/http/adapters/httpx_adapter.py

@@ -186,7 +186,16 @@ class HTTPXClient:
         # Try to get error message from response
         try:
             error_data = httpx_response.json()
-            error_message = error_data.get("message") or error_data.get("error") or str(error_data)
+            errors_list = error_data.get("errors")
+            if isinstance(errors_list, list):
+
+                def _extract_error(e: object) -> str:
+                    if isinstance(e, dict):
+                        return str(e.get("userPresentableMessage") or e.get("message") or e.get("error") or e)
+                    return str(e)
+
+                errors_list = ", ".join(_extract_error(e) for e in errors_list)
+            error_message = errors_list or error_data.get("message") or error_data.get("error") or str(error_data)
         except Exception:
             error_message = httpx_response.text or f"HTTP {status_code} error"
 

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/_vendored/connector_sdk/schema/base.py

@@ -126,6 +126,17 @@ class Info(BaseModel):
     x_airbyte_example_questions: ExampleQuestions | None = Field(None, alias="x-airbyte-example-questions")
     x_airbyte_cache: CacheConfig | None = Field(None, alias="x-airbyte-cache")
     x_airbyte_replication_config: ReplicationConfig | None = Field(None, alias="x-airbyte-replication-config")
+    x_airbyte_skip_suggested_streams: list[str] = Field(
+        default_factory=list,
+        alias="x-airbyte-skip-suggested-streams",
+        description="List of Airbyte suggested streams to skip when validating cache entity coverage",
+    )
+    x_airbyte_skip_auth_methods: list[str] = Field(
+        default_factory=list,
+        alias="x-airbyte-skip-auth-methods",
+        description="List of Airbyte auth methods to skip when validating auth compatibility. "
+        "Use the SelectiveAuthenticator option key (e.g., 'Private App Credentials', 'oauth2.0')",
+    )
 
 
 class ServerVariable(BaseModel):

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/_vendored/connector_sdk/schema/security.py

@@ -199,6 +199,11 @@ class SecurityScheme(BaseModel):
         alias="x-airbyte-token-extract",
         description="List of fields to extract from OAuth2 token responses and use as server variables",
     )
+    x_airbyte_untested: bool = Field(
+        False,
+        alias="x-airbyte-untested",
+        description="Mark this auth scheme as untested to skip cassette coverage validation",
+    )
 
     @field_validator("x_airbyte_token_extract", mode="after")
     @classmethod

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/_vendored/connector_sdk/telemetry/tracker.py

@@ -3,7 +3,7 @@
 import logging
 import platform
 import sys
-from datetime import datetime
+from datetime import UTC, datetime
 
 from ..observability import ObservabilitySession
 
@@ -56,7 +56,7 @@ class SegmentTracker:
 
         try:
             event = ConnectorInitEvent(
-                timestamp=datetime.utcnow(),
+                timestamp=datetime.now(UTC),
                 session_id=self.session.session_id,
                 user_id=self.session.user_id,
                 execution_context=self.session.execution_context,
@@ -99,7 +99,7 @@ class SegmentTracker:
 
         try:
             event = OperationEvent(
-                timestamp=datetime.utcnow(),
+                timestamp=datetime.now(UTC),
                 session_id=self.session.session_id,
                 user_id=self.session.user_id,
                 execution_context=self.session.execution_context,
@@ -129,7 +129,7 @@ class SegmentTracker:
 
         try:
             event = SessionEndEvent(
-                timestamp=datetime.utcnow(),
+                timestamp=datetime.now(UTC),
                 session_id=self.session.session_id,
                 user_id=self.session.user_id,
                 execution_context=self.session.execution_context,

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/_vendored/connector_sdk/types.py

@@ -90,6 +90,10 @@ class AuthOption(BaseModel):
         None,
         description="User-facing credential specification from x-airbyte-auth-config",
     )
+    untested: bool = Field(
+        False,
+        description="Mark this auth scheme as untested to skip cassette coverage validation",
+    )
 
 
 class AuthConfig(BaseModel):

airbyte_agent_slack-0.1.38/airbyte_agent_slack/_vendored/connector_sdk/utils.py

@@ -0,0 +1,127 @@
+"""Utility functions for working with connectors."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .types import AuthOption
+
+
+async def save_download(
+    download_iterator: AsyncIterator[bytes],
+    path: str | Path,
+    *,
+    overwrite: bool = False,
+) -> Path:
+    """Save a download iterator to a file.
+
+    Args:
+        download_iterator: AsyncIterator[bytes] from a download operation
+        path: File path where content should be saved
+        overwrite: Whether to overwrite existing file (default: False)
+
+    Returns:
+        Absolute Path to the saved file
+
+    Raises:
+        FileExistsError: If file exists and overwrite=False
+        OSError: If file cannot be written
+
+    Example:
+        >>> from .utils import save_download
+        >>>
+        >>> # Download and save a file
+        >>> result = await connector.download_article_attachment(id="123")
+        >>> file_path = await save_download(result, "./downloads/attachment.pdf")
+        >>> print(f"Downloaded to {file_path}")
+        Downloaded to /absolute/path/to/downloads/attachment.pdf
+        >>>
+        >>> # Overwrite existing file
+        >>> file_path = await save_download(result, "./downloads/attachment.pdf", overwrite=True)
+    """
+    # Convert to Path object
+    file_path = Path(path).expanduser().resolve()
+
+    # Check if file exists
+    if file_path.exists() and not overwrite:
+        raise FileExistsError(f"File already exists: {file_path}. Use overwrite=True to replace it.")
+
+    # Create parent directories if needed
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Stream content to file
+    try:
+        with open(file_path, "wb") as f:
+            async for chunk in download_iterator:
+                f.write(chunk)
+    except Exception as e:
+        # Clean up partial file on error
+        if file_path.exists():
+            file_path.unlink()
+        raise OSError(f"Failed to write file {file_path}: {e}") from e
+
+    return file_path
+
+
+def find_matching_auth_options(
+    provided_keys: set[str],
+    auth_options: list[AuthOption],
+) -> list[AuthOption]:
+    """Find auth options that match the provided credential keys.
+
+    This is the single source of truth for auth scheme inference logic,
+    used by both the executor (at runtime) and validation (for cassettes).
+
+    Matching logic:
+    - An option matches if all its required fields are present in provided_keys
+    - Options with no required fields match any credentials
+
+    Args:
+        provided_keys: Set of credential/auth_config keys
+        auth_options: List of AuthOption from the connector model
+
+    Returns:
+        List of AuthOption that match the provided keys
+    """
+    matching_options: list[AuthOption] = []
+
+    for option in auth_options:
+        if option.user_config_spec and option.user_config_spec.required:
+            required_fields = set(option.user_config_spec.required)
+            if required_fields.issubset(provided_keys):
+                matching_options.append(option)
+        elif not option.user_config_spec or not option.user_config_spec.required:
+            # Option has no required fields - it matches any credentials
+            matching_options.append(option)
+
+    return matching_options
+
+
+def infer_auth_scheme_name(
+    provided_keys: set[str],
+    auth_options: list[AuthOption],
+) -> str | None:
+    """Infer the auth scheme name from provided credential keys.
+
+    Uses find_matching_auth_options to find matches, then returns
+    the scheme name only if exactly one option matches.
+
+    Args:
+        provided_keys: Set of credential/auth_config keys
+        auth_options: List of AuthOption from the connector model
+
+    Returns:
+        The scheme_name if exactly one match, None otherwise
+    """
+    if not provided_keys or not auth_options:
+        return None
+
+    matching = find_matching_auth_options(provided_keys, auth_options)
+
+    if len(matching) == 1:
+        return matching[0].scheme_name
+
+    return None

{airbyte_agent_slack-0.1.33 → airbyte_agent_slack-0.1.38}/airbyte_agent_slack/_vendored/connector_sdk/validation.py

@@ -5,6 +5,7 @@ These tools help ensure that connectors are ready to ship by:
 - Checking that all entity/action operations have corresponding test cassettes
 - Validating that response schemas match the actual cassette responses
 - Detecting fields present in responses but not declared in schemas
+- Validating replication compatibility with Airbyte source connectors
 """
 
 from collections import defaultdict
@@ -20,7 +21,9 @@ from .connector_model_loader import (
     load_connector_model,
 )
 from .testing.spec_loader import load_test_spec
-from .types import Action, EndpointDefinition
+from .types import Action, ConnectorModel, EndpointDefinition
+from .utils import infer_auth_scheme_name
+from .validation_replication import validate_replication_compatibility
 
 
 def build_cassette_map(cassettes_dir: Path) -> Dict[Tuple[str, str], List[Path]]:
@@ -51,6 +54,112 @@ def build_cassette_map(cassettes_dir: Path) -> Dict[Tuple[str, str], List[Path]]
     return dict(cassette_map)
 
 
+def build_auth_scheme_coverage(
+    cassettes_dir: Path,
+    auth_options: list | None = None,
+) -> Tuple[Dict[str | None, List[Path]], List[Tuple[Path, set[str]]]]:
+    """Build a map of auth_scheme -> list of cassette paths.
+
+    For multi-auth connectors, infers the auth scheme from the cassette's auth_config
+    keys using the same matching logic as the executor.
+
+    Args:
+        cassettes_dir: Directory containing cassette YAML files
+        auth_options: List of AuthOption from the connector model (for inference)
+
+    Returns:
+        Tuple of:
+        - Dictionary mapping auth_scheme names (or None for single-auth) to cassette paths
+        - List of (cassette_path, auth_config_keys) for cassettes that couldn't be matched
+    """
+    auth_scheme_map: Dict[str | None, List[Path]] = defaultdict(list)
+    unmatched_cassettes: List[Tuple[Path, set[str]]] = []
+
+    if not cassettes_dir.exists() or not cassettes_dir.is_dir():
+        return {}, []
+
+    for cassette_file in cassettes_dir.glob("*.yaml"):
+        try:
+            spec = load_test_spec(cassette_file, auth_config={})
+
+            # First, check if auth_scheme is explicitly set in the cassette
+            if spec.auth_scheme:
+                auth_scheme_map[spec.auth_scheme].append(cassette_file)
+            # Otherwise, try to infer from auth_config keys
+            elif spec.auth_config and auth_options:
+                auth_config_keys = set(spec.auth_config.keys())
+                inferred_scheme = infer_auth_scheme_name(auth_config_keys, auth_options)
+                if inferred_scheme is not None:
+                    auth_scheme_map[inferred_scheme].append(cassette_file)
+                else:
+                    # Couldn't infer - track as unmatched
+                    unmatched_cassettes.append((cassette_file, auth_config_keys))
+            else:
+                # No auth_scheme and no auth_config - treat as None
+                auth_scheme_map[None].append(cassette_file)
+        except Exception:
+            continue
+
+    return dict(auth_scheme_map), unmatched_cassettes
+
+
+def validate_auth_scheme_coverage(
+    config: ConnectorModel,
+    cassettes_dir: Path,
+) -> Tuple[bool, List[str], List[str], List[str], List[Tuple[Path, set[str]]]]:
+    """Validate that each auth scheme has at least one cassette.
+
+    For multi-auth connectors, every defined auth scheme must have coverage
+    unless marked with x-airbyte-untested: true.
+    For single-auth connectors, this check is skipped (existing cassette checks suffice).
+
+    Args:
+        config: Loaded connector model
+        cassettes_dir: Directory containing cassette files
+
+    Returns:
+        Tuple of (is_valid, errors, warnings, covered_schemes, unmatched_cassettes)
+    """
+    errors: List[str] = []
+    warnings: List[str] = []
+
+    # Skip check for single-auth connectors
+    if not config.auth.is_multi_auth():
+        return True, errors, warnings, [], []
+
+    # Get all defined auth schemes, separating tested from untested
+    options = config.auth.options or []
+
+    # Build auth scheme coverage from cassettes (pass options for inference)
+    auth_scheme_coverage, unmatched_cassettes = build_auth_scheme_coverage(cassettes_dir, options)
+    tested_schemes = {opt.scheme_name for opt in options if not opt.untested}
+    untested_schemes = {opt.scheme_name for opt in options if opt.untested}
+    covered_schemes = {scheme for scheme in auth_scheme_coverage.keys() if scheme is not None}
+
+    # Find missing tested schemes (errors)
+    missing_tested = tested_schemes - covered_schemes
+    for scheme in sorted(missing_tested):
+        errors.append(
+            f"Auth scheme '{scheme}' has no cassette coverage. "
+            f"Record at least one cassette using this authentication method, "
+            f"or add 'x-airbyte-untested: true' to skip this check."
+        )
+
+    # Warn about untested schemes without coverage
+    missing_untested = untested_schemes - covered_schemes
+    for scheme in sorted(missing_untested):
+        warnings.append(
+            f"Auth scheme '{scheme}' is marked as untested (x-airbyte-untested: true) " f"and has no cassette coverage. Validation skipped."
+        )
+
+    # Warn about cassettes that couldn't be matched to any auth scheme
+    for cassette_path, auth_config_keys in unmatched_cassettes:
+        warnings.append(f"Cassette '{cassette_path.name}' could not be matched to any auth scheme. " f"auth_config keys: {sorted(auth_config_keys)}")
+
+    is_valid = len(missing_tested) == 0
+    return is_valid, errors, warnings, sorted(covered_schemes), unmatched_cassettes
+
+
 def validate_response_against_schema(response_body: Any, schema: Dict[str, Any]) -> Tuple[bool, List[str]]:
     """Validate a response body against a JSON schema.
 
@@ -586,6 +695,9 @@ def validate_connector_readiness(connector_dir: str | Path) -> Dict[str, Any]:
     cassettes_dir = connector_path / "tests" / "cassettes"
     cassette_map = build_cassette_map(cassettes_dir)
 
+    # Validate auth scheme coverage for multi-auth connectors
+    auth_valid, auth_errors, auth_warnings, auth_covered_schemes, auth_unmatched_cassettes = validate_auth_scheme_coverage(config, cassettes_dir)
+
     validation_results = []
     total_operations = 0
     operations_with_cassettes = 0
@@ -808,7 +920,29 @@ def validate_connector_readiness(connector_dir: str | Path) -> Dict[str, Any]:
                 }
             )
 
-    success = operations_missing_cassettes == 0 and cassettes_invalid == 0 and total_operations > 0
+    # Validate replication compatibility with Airbyte
+    replication_result = validate_replication_compatibility(
+        connector_yaml_path=config_file,
+        raw_spec=raw_spec,
+    )
+
+    # Merge replication errors/warnings into totals
+    # Note: If connector is not in registry, we don't count warnings since this is expected for test connectors
+    replication_errors = replication_result.get("errors", [])
+    replication_warnings = replication_result.get("warnings", [])
+    total_errors += len(replication_errors)
+
+    # Only count replication warnings if the connector was found in the registry
+    # (i.e., there are actual validation issues, not just "not found in registry")
+    if replication_result.get("registry_found", False):
+        total_warnings += len(replication_warnings)
+
+    # Merge auth scheme validation errors/warnings into totals
+    total_errors += len(auth_errors)
+    total_warnings += len(auth_warnings)
+
+    # Update success criteria to include replication and auth scheme validation
+    success = operations_missing_cassettes == 0 and cassettes_invalid == 0 and total_operations > 0 and len(replication_errors) == 0 and auth_valid
 
     # Check for preferred_for_check on at least one list operation
     has_preferred_check = False
@@ -829,11 +963,26 @@ def validate_connector_readiness(connector_dir: str | Path) -> Dict[str, Any]:
             "to enable reliable health checks."
         )
 
+    # Build auth scheme validation result
+    options = config.auth.options or []
+    tested_schemes = [opt.scheme_name for opt in options if not opt.untested]
+    untested_schemes_list = [opt.scheme_name for opt in options if opt.untested]
+    missing_tested = [s for s in tested_schemes if s not in auth_covered_schemes]
+
     return {
         "success": success,
         "connector_name": config.name,
         "connector_path": str(connector_path),
         "validation_results": validation_results,
+        "replication_validation": replication_result,
+        "auth_scheme_validation": {
+            "valid": auth_valid,
+            "errors": auth_errors,
+            "warnings": auth_warnings,
+            "covered_schemes": auth_covered_schemes,
+            "missing_schemes": missing_tested,
+            "untested_schemes": untested_schemes_list,
+        },
         "readiness_warnings": readiness_warnings,
         "summary": {
             "total_operations": total_operations,