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

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

@@ -1,5 +1,10 @@
 # Slack changelog
 
+## [0.1.39] - 2026-01-30
+- Updated connector definition (YAML version 0.1.12)
+- Source commit: b184da3e
+- SDK version: 0.1.0
+
 ## [0.1.38] - 2026-01-30
 - Updated connector definition (YAML version 0.1.12)
 - Source commit: 40765c71

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-agent-slack
-Version: 0.1.38
+Version: 0.1.39
 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,7 +158,7 @@ See the official [Slack API reference](https://api.slack.com/methods).
 
 ## Version information
 
-- **Package version:** 0.1.38
+- **Package version:** 0.1.39
 - **Connector version:** 0.1.12
-- **Generated with Connector SDK commit SHA:** 40765c717093dffed8c5e9ed8d5b3a6fbbe9b181
+- **Generated with Connector SDK commit SHA:** b184da3e22ef8521d2eeebf3c96a0fe8da2424f5
 - **Changelog:** [View changelog](https://github.com/airbytehq/airbyte-agent-connectors/blob/main/connectors/slack/CHANGELOG.md)

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

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

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

@@ -7,6 +7,7 @@ Auto-generated from OpenAPI specification.
 from .connector import SlackConnector
 from .models import (
     SlackAuthConfig,
+    SlackReplicationConfig,
     User,
     UserProfile,
     ResponseMetadata,
@@ -17,9 +18,9 @@ from .models import (
     ChannelPurpose,
     ChannelsListResponse,
     ChannelResponse,
-    Reaction,
     Attachment,
     File,
+    Reaction,
     Message,
     Thread,
     EditedInfo,
@@ -86,6 +87,7 @@ from .types import (
 __all__ = [
     "SlackConnector",
     "SlackAuthConfig",
+    "SlackReplicationConfig",
     "User",
     "UserProfile",
     "ResponseMetadata",
@@ -96,9 +98,9 @@ __all__ = [
     "ChannelPurpose",
     "ChannelsListResponse",
     "ChannelResponse",
-    "Reaction",
     "Attachment",
     "File",
+    "Reaction",
     "Message",
     "Thread",
     "EditedInfo",

{airbyte_agent_slack-0.1.38 → airbyte_agent_slack-0.1.39}/airbyte_agent_slack/_vendored/connector_sdk/cloud_utils/client.py

@@ -161,6 +161,68 @@ class AirbyteCloudClient:
         connector_id = connectors[0]["id"]
         return connector_id
 
+    async def create_source(
+        self,
+        name: str,
+        connector_definition_id: str,
+        external_user_id: str,
+        credentials: dict[str, Any],
+        replication_config: dict[str, Any] | None = None,
+    ) -> str:
+        """Create a new source on Airbyte Agent Platform.
+
+        Args:
+            name: Source name
+            connector_definition_id: UUID of the connector definition
+            external_user_id: User identifier
+            credentials: Connector auth config dict
+            replication_config: Optional replication settings (e.g., start_date for
+                connectors with x-airbyte-replication-config). Required for REPLICATION
+                mode sources like Intercom.
+
+        Returns:
+            The created source ID (UUID string)
+
+        Raises:
+            httpx.HTTPStatusError: If creation fails
+
+        Example:
+            source_id = await client.create_source(
+                name="My Gong Source",
+                connector_definition_id="32382e40-3b49-4b99-9c5c-4076501914e7",
+                external_user_id="my-workspace",
+                credentials={"access_key": "...", "access_key_secret": "..."}
+            )
+
+            # For REPLICATION mode sources (e.g., Intercom):
+            source_id = await client.create_source(
+                name="My Intercom Source",
+                connector_definition_id="d8313939-3782-41b0-be29-b3ca20d8dd3a",
+                external_user_id="my-workspace",
+                credentials={"access_token": "..."},
+                replication_config={"start_date": "2024-01-01T00:00:00Z"}
+            )
+        """
+        token = await self.get_bearer_token()
+        url = f"{self.API_BASE_URL}/v1/integrations/connectors"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        request_body: dict[str, Any] = {
+            "name": name,
+            "definition_id": connector_definition_id,
+            "external_user_id": external_user_id,
+            "credentials": credentials,
+        }
+
+        if replication_config is not None:
+            request_body["replication_config"] = replication_config
+
+        response = await self._http_client.post(url, json=request_body, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        return data["id"]
+
     async def execute_connector(
         self,
         connector_id: str,

{airbyte_agent_slack-0.1.38 → airbyte_agent_slack-0.1.39}/airbyte_agent_slack/_vendored/connector_sdk/executor/hosted_executor.py

@@ -19,19 +19,26 @@ class HostedExecutor:
     instead of directly calling external services. The cloud API handles all
     connector logic, secrets management, and execution.
 
-    The executor takes an external_user_id and uses the AirbyteCloudClient to:
+    The executor uses the AirbyteCloudClient to:
     1. Authenticate with the Airbyte Platform (bearer token with caching)
-    2. Look up the user's connector
+    2. Look up the user's connector (if connector_id not provided)
     3. Execute the connector operation via the cloud API
 
     Implements ExecutorProtocol.
 
     Example:
-        # Create executor with user ID, credentials, and connector definition ID
+        # Create executor with explicit connector_id (no lookup needed)
+        executor = HostedExecutor(
+            airbyte_client_id="client_abc123",
+            airbyte_client_secret="secret_xyz789",
+            connector_id="existing-source-uuid",
+        )
+
+        # Or create executor with user ID for lookup
         executor = HostedExecutor(
-            external_user_id="user-123",
             airbyte_client_id="client_abc123",
             airbyte_client_secret="secret_xyz789",
+            external_user_id="user-123",
             connector_definition_id="abc123-def456-ghi789",
         )
 
@@ -51,28 +58,48 @@ class HostedExecutor:
 
     def __init__(
         self,
-        external_user_id: str,
         airbyte_client_id: str,
         airbyte_client_secret: str,
-        connector_definition_id: str,
+        connector_id: str | None = None,
+        external_user_id: str | None = None,
+        connector_definition_id: str | None = None,
     ):
         """Initialize hosted executor.
 
+        Either provide connector_id directly OR (external_user_id + connector_definition_id)
+        for lookup.
+
         Args:
-            external_user_id: User identifier in the Airbyte system
             airbyte_client_id: Airbyte client ID for authentication
             airbyte_client_secret: Airbyte client secret for authentication
-            connector_definition_id: Connector definition ID used to look up
-                the user's connector.
+            connector_id: Direct connector/source ID (skips lookup if provided)
+            external_user_id: User identifier in the Airbyte system (for lookup)
+            connector_definition_id: Connector definition ID (for lookup)
+
+        Raises:
+            ValueError: If neither connector_id nor (external_user_id + connector_definition_id) provided
 
         Example:
+            # With explicit connector_id (no lookup)
+            executor = HostedExecutor(
+                airbyte_client_id="client_abc123",
+                airbyte_client_secret="secret_xyz789",
+                connector_id="existing-source-uuid",
+            )
+
+            # With lookup by user + definition
             executor = HostedExecutor(
-                external_user_id="user-123",
                 airbyte_client_id="client_abc123",
                 airbyte_client_secret="secret_xyz789",
+                external_user_id="user-123",
                 connector_definition_id="abc123-def456-ghi789",
             )
         """
+        # Validate: either connector_id OR (external_user_id + connector_definition_id) required
+        if not connector_id and not (external_user_id and connector_definition_id):
+            raise ValueError("Either connector_id OR (external_user_id + connector_definition_id) must be provided")
+
+        self._connector_id = connector_id
         self._external_user_id = external_user_id
         self._connector_definition_id = connector_definition_id
 
@@ -86,10 +113,9 @@ class HostedExecutor:
         """Execute connector via cloud API (ExecutorProtocol implementation).
 
         Flow:
-        1. Get connector definition id from executor config
-        2. Look up the user's connector ID
-        3. Execute the connector operation via the cloud API
-        4. Parse the response into ExecutionResult
+        1. Use provided connector_id or look up from external_user_id + definition_id
+        2. Execute the connector operation via the cloud API
+        3. Parse the response into ExecutionResult
 
         Args:
             config: Execution configuration (entity, action, params)
@@ -98,7 +124,7 @@ class HostedExecutor:
             ExecutionResult with success/failure status
 
         Raises:
-            ValueError: If no connector or multiple connectors found for user
+            ValueError: If no connector or multiple connectors found for user (when doing lookup)
             httpx.HTTPStatusError: If API returns 4xx/5xx status code
             httpx.RequestError: If network request fails
 
@@ -114,23 +140,26 @@ class HostedExecutor:
 
         with tracer.start_as_current_span("airbyte.hosted_executor.execute") as span:
             # Add span attributes for observability
-            span.set_attribute("connector.definition_id", self._connector_definition_id)
+            if self._connector_definition_id:
+                span.set_attribute("connector.definition_id", self._connector_definition_id)
             span.set_attribute("connector.entity", config.entity)
             span.set_attribute("connector.action", config.action)
-            span.set_attribute("user.external_id", self._external_user_id)
+            if self._external_user_id:
+                span.set_attribute("user.external_id", self._external_user_id)
             if config.params:
                 # Only add non-sensitive param keys
                 span.set_attribute("connector.param_keys", list(config.params.keys()))
 
             try:
-                # Step 1: Get connector definition id
-                connector_definition_id = self._connector_definition_id
-
-                # Step 2: Get the connector ID for this user
-                connector_id = await self._cloud_client.get_connector_id(
-                    external_user_id=self._external_user_id,
-                    connector_definition_id=connector_definition_id,
-                )
+                # Use provided connector_id or look it up
+                if self._connector_id:
+                    connector_id = self._connector_id
+                else:
+                    # Look up connector by external_user_id + definition_id
+                    connector_id = await self._cloud_client.get_connector_id(
+                        external_user_id=self._external_user_id,  # type: ignore[arg-type]
+                        connector_definition_id=self._connector_definition_id,  # type: ignore[arg-type]
+                    )
 
                 span.set_attribute("connector.connector_id", connector_id)
 

{airbyte_agent_slack-0.1.38 → airbyte_agent_slack-0.1.39}/airbyte_agent_slack/connector.py

@@ -38,6 +38,8 @@ from .types import (
 )
 if TYPE_CHECKING:
     from .models import SlackAuthConfig
+    from .models import SlackReplicationConfig
+
 # Import specific auth config classes for multi-auth isinstance checks
 from .models import SlackTokenAuthenticationAuthConfig, SlackOauth20AuthenticationAuthConfig
 # Import response models and envelope models at runtime
@@ -152,26 +154,35 @@ class SlackConnector:
         external_user_id: str | None = None,
         airbyte_client_id: str | None = None,
         airbyte_client_secret: str | None = None,
+        connector_id: str | None = None,
         on_token_refresh: Any | None = None    ):
         """
         Initialize a new slack connector instance.
 
         Supports both local and hosted execution modes:
         - Local mode: Provide `auth_config` for direct API calls
-        - Hosted mode: Provide `external_user_id`, `airbyte_client_id`, and `airbyte_client_secret` for hosted execution
+        - Hosted mode: Provide Airbyte credentials with either `connector_id` or `external_user_id`
 
         Args:
             auth_config: Typed authentication configuration (required for local mode)
-            external_user_id: External user ID (required for hosted mode)
+            external_user_id: External user ID (for hosted mode lookup)
             airbyte_client_id: Airbyte OAuth client ID (required for hosted mode)
             airbyte_client_secret: Airbyte OAuth client secret (required for hosted mode)
+            connector_id: Specific connector/source ID (for hosted mode, skips lookup)
             on_token_refresh: Optional callback for OAuth2 token refresh persistence.
                 Called with new_tokens dict when tokens are refreshed. Can be sync or async.
                 Example: lambda tokens: save_to_database(tokens)
         Examples:
             # Local mode (direct API calls)
             connector = SlackConnector(auth_config=SlackAuthConfig(api_token="..."))
-            # Hosted mode (executed on Airbyte cloud)
+            # Hosted mode with explicit connector_id (no lookup needed)
+            connector = SlackConnector(
+                airbyte_client_id="client_abc123",
+                airbyte_client_secret="secret_xyz789",
+                connector_id="existing-source-uuid"
+            )
+
+            # Hosted mode with lookup by external_user_id
             connector = SlackConnector(
                 external_user_id="user-123",
                 airbyte_client_id="client_abc123",
@@ -189,21 +200,24 @@ class SlackConnector:
                 on_token_refresh=save_tokens
             )
         """
-        # Hosted mode: external_user_id, airbyte_client_id, and airbyte_client_secret provided
-        if external_user_id and airbyte_client_id and airbyte_client_secret:
+        # Hosted mode: Airbyte credentials + either connector_id OR external_user_id
+        is_hosted = airbyte_client_id and airbyte_client_secret and (connector_id or external_user_id)
+
+        if is_hosted:
             from ._vendored.connector_sdk.executor import HostedExecutor
             self._executor = HostedExecutor(
-                external_user_id=external_user_id,
                 airbyte_client_id=airbyte_client_id,
                 airbyte_client_secret=airbyte_client_secret,
-                connector_definition_id=str(SlackConnectorModel.id),
+                connector_id=connector_id,
+                external_user_id=external_user_id,
+                connector_definition_id=str(SlackConnectorModel.id) if not connector_id else None,
             )
         else:
             # Local mode: auth_config required
             if not auth_config:
                 raise ValueError(
-                    "Either provide (external_user_id, airbyte_client_id, airbyte_client_secret) for hosted mode "
-                    "or auth_config for local mode"
+                    "Either provide Airbyte credentials (airbyte_client_id, airbyte_client_secret) with "
+                    "connector_id or external_user_id for hosted mode, or auth_config for local mode"
                 )
 
             from ._vendored.connector_sdk.executor import LocalExecutor
@@ -567,6 +581,105 @@ class SlackConnector:
             )
         return entity_def.entity_schema if entity_def else None
 
+    @property
+    def connector_id(self) -> str | None:
+        """Get the connector/source ID (only available in hosted mode).
+
+        Returns:
+            The connector ID if in hosted mode, None if in local mode.
+
+        Example:
+            connector = await SlackConnector.create_hosted(...)
+            print(f"Created connector: {connector.connector_id}")
+        """
+        if hasattr(self, '_executor') and hasattr(self._executor, '_connector_id'):
+            return self._executor._connector_id
+        return None
+
+    # ===== HOSTED MODE FACTORY =====
+
+    @classmethod
+    async def create_hosted(
+        cls,
+        *,
+        external_user_id: str,
+        airbyte_client_id: str,
+        airbyte_client_secret: str,
+        auth_config: "SlackAuthConfig",
+        name: str | None = None,
+        replication_config: "SlackReplicationConfig" | None = None,
+    ) -> "SlackConnector":
+        """
+        Create a new hosted connector on Airbyte Cloud.
+
+        This factory method:
+        1. Creates a source on Airbyte Cloud with the provided credentials
+        2. Returns a connector configured with the new connector_id
+
+        Args:
+            external_user_id: Workspace identifier in Airbyte Cloud
+            airbyte_client_id: Airbyte OAuth client ID
+            airbyte_client_secret: Airbyte OAuth client secret
+            auth_config: Typed auth config (same as local mode)
+            name: Optional source name (defaults to connector name + external_user_id)
+            replication_config: Typed replication settings.
+                Required for connectors with x-airbyte-replication-config (REPLICATION mode sources).
+
+        Returns:
+            A SlackConnector instance configured in hosted mode
+
+        Example:
+            # Create a new hosted connector with API key auth
+            connector = await SlackConnector.create_hosted(
+                external_user_id="my-workspace",
+                airbyte_client_id="client_abc",
+                airbyte_client_secret="secret_xyz",
+                auth_config=SlackAuthConfig(api_token="..."),
+            )
+
+            # With replication config (required for this connector):
+            connector = await SlackConnector.create_hosted(
+                external_user_id="my-workspace",
+                airbyte_client_id="client_abc",
+                airbyte_client_secret="secret_xyz",
+                auth_config=SlackAuthConfig(api_token="..."),
+                replication_config=SlackReplicationConfig(start_date="...", lookback_window="...", join_channels="..."),
+            )
+
+            # Use the connector
+            result = await connector.execute("entity", "list", {})
+        """
+        from ._vendored.connector_sdk.cloud_utils import AirbyteCloudClient
+
+        client = AirbyteCloudClient(
+            client_id=airbyte_client_id,
+            client_secret=airbyte_client_secret,
+        )
+
+        try:
+            # Build credentials from auth_config
+            credentials = auth_config.model_dump(exclude_none=True)
+            replication_config_dict = replication_config.model_dump(exclude_none=True) if replication_config else None
+
+            # Create source on Airbyte Cloud
+            source_name = name or f"{cls.connector_name} - {external_user_id}"
+            source_id = await client.create_source(
+                name=source_name,
+                connector_definition_id=str(SlackConnectorModel.id),
+                external_user_id=external_user_id,
+                credentials=credentials,
+                replication_config=replication_config_dict,
+            )
+        finally:
+            await client.close()
+
+        # Return connector configured with the new connector_id
+        return cls(
+            airbyte_client_id=airbyte_client_id,
+            airbyte_client_secret=airbyte_client_secret,
+            connector_id=source_id,
+        )
+
 
 
 class UsersQuery:

{airbyte_agent_slack-0.1.38 → airbyte_agent_slack-0.1.39}/airbyte_agent_slack/models.py

@@ -34,6 +34,20 @@ class SlackOauth20AuthenticationAuthConfig(BaseModel):
 
 SlackAuthConfig = SlackTokenAuthenticationAuthConfig | SlackOauth20AuthenticationAuthConfig
 
+# Replication configuration
+
+class SlackReplicationConfig(BaseModel):
+    """Replication Configuration - Settings for data replication from Slack."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    start_date: str
+    """UTC date and time in the format YYYY-MM-DDTHH:mm:ssZ from which to start replicating data."""
+    lookback_window: int
+    """Number of days to look back when syncing data (0-365)."""
+    join_channels: bool
+    """Whether to automatically join public channels to sync messages."""
+
 # ===== RESPONSE TYPE DEFINITIONS (PYDANTIC) =====
 
 class User(BaseModel):
@@ -176,14 +190,6 @@ class ChannelResponse(BaseModel):
     ok: Union[bool, Any] = Field(default=None)
     channel: Union[Channel, Any] = Field(default=None)
 
-class Reaction(BaseModel):
-    """Message reaction"""
-    model_config = ConfigDict(extra="allow", populate_by_name=True)
-
-    name: Union[str | None, Any] = Field(default=None)
-    users: Union[list[str] | None, Any] = Field(default=None)
-    count: Union[int | None, Any] = Field(default=None)
-
 class Attachment(BaseModel):
     """Message attachment"""
     model_config = ConfigDict(extra="allow", populate_by_name=True)
@@ -229,6 +235,14 @@ class File(BaseModel):
     created: Union[int | None, Any] = Field(default=None)
     timestamp: Union[int | None, Any] = Field(default=None)
 
+class Reaction(BaseModel):
+    """Message reaction"""
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    name: Union[str | None, Any] = Field(default=None)
+    users: Union[list[str] | None, Any] = Field(default=None)
+    count: Union[int | None, Any] = Field(default=None)
+
 class Message(BaseModel):
     """Slack message object"""
     model_config = ConfigDict(extra="allow", populate_by_name=True)

{airbyte_agent_slack-0.1.38 → airbyte_agent_slack-0.1.39}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "airbyte-agent-slack"
-version = "0.1.38"
+version = "0.1.39"
 description = "Airbyte Slack Connector for AI platforms"
 readme = "README.md"
 requires-python = ">=3.13"