airbyte-agent-slack 0.1.15__py3-none-any.whl → 0.1.25__py3-none-any.whl

airbyte_agent_slack/_vendored/connector_sdk/schema/extensions.py

@@ -182,6 +182,77 @@ class CacheEntityConfig(BaseModel):
         return self.x_airbyte_name or self.entity
 
 
+class ReplicationConfigProperty(BaseModel):
+    """
+    Property definition for replication configuration fields.
+
+    Defines a single field in the replication configuration with its type,
+    description, and optional default value.
+
+    Example YAML usage:
+        x-airbyte-replication-config:
+          properties:
+            start_date:
+              type: string
+              title: Start Date
+              description: UTC date and time from which to replicate data
+              format: date-time
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    type: str
+    title: str | None = None
+    description: str | None = None
+    format: str | None = None
+    default: str | int | float | bool | None = None
+    enum: list[str] | None = None
+
+
+class ReplicationConfig(BaseModel):
+    """
+    Replication configuration extension (x-airbyte-replication-config).
+
+    Defines replication-specific settings for MULTI mode connectors that need
+    to configure the underlying replication connector. This allows users who
+    use the direct-style API (credentials + environment) to also specify
+    replication settings like start_date, lookback_window, etc.
+
+    This extension is added to the Info model and provides field definitions
+    for replication configuration that gets merged into the source config
+    when creating sources.
+
+    Example YAML usage:
+        info:
+          title: HubSpot API
+          x-airbyte-replication-config:
+            title: Replication Configuration
+            description: Settings for data replication
+            properties:
+              start_date:
+                type: string
+                title: Start Date
+                description: UTC date and time from which to replicate data
+                format: date-time
+            required:
+              - start_date
+            replication_config_key_mapping:
+              start_date: start_date
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    title: str | None = None
+    description: str | None = None
+    properties: dict[str, ReplicationConfigProperty] = Field(default_factory=dict)
+    required: list[str] = Field(default_factory=list)
+    replication_config_key_mapping: dict[str, str] = Field(
+        default_factory=dict,
+        alias="replication_config_key_mapping",
+        description="Mapping from replication_config field names to source_config field names",
+    )
+
+
 class CacheConfig(BaseModel):
     """
     Cache configuration extension (x-airbyte-cache).

airbyte_agent_slack/_vendored/connector_sdk/types.py

@@ -252,3 +252,4 @@ class ConnectorModel(BaseModel):
     entities: list[EntityDefinition]
     openapi_spec: Any | None = None  # Optional reference to OpenAPIConnector
     retry_config: RetryConfig | None = None  # Optional retry configuration
+    search_field_paths: dict[str, list[str]] | None = None

airbyte_agent_slack/connector.py

@@ -4,8 +4,11 @@ Slack connector.
 
 from __future__ import annotations
 
+import inspect
+import json
 import logging
-from typing import TYPE_CHECKING, Any, Callable, TypeVar, overload
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Mapping, TypeVar, overload
 try:
     from typing import Literal
 except ImportError:
@@ -27,6 +30,11 @@ from .types import (
     ThreadsListParams,
     UsersGetParams,
     UsersListParams,
+    AirbyteSearchParams,
+    ChannelsSearchFilter,
+    ChannelsSearchQuery,
+    UsersSearchFilter,
+    UsersSearchQuery,
 )
 if TYPE_CHECKING:
     from .models import SlackAuthConfig
@@ -46,11 +54,49 @@ from .models import (
     ReactionAddResponse,
     Thread,
     User,
+    AirbyteSearchHit,
+    AirbyteSearchResult,
+    ChannelsSearchData,
+    ChannelsSearchResult,
+    UsersSearchData,
+    UsersSearchResult,
 )
 
 # TypeVar for decorator type preservation
 _F = TypeVar("_F", bound=Callable[..., Any])
 
+DEFAULT_MAX_OUTPUT_CHARS = 50_000  # ~50KB default, configurable per-tool
+
+
+def _raise_output_too_large(message: str) -> None:
+    try:
+        from pydantic_ai import ModelRetry  # type: ignore[import-not-found]
+    except Exception as exc:
+        raise RuntimeError(message) from exc
+    raise ModelRetry(message)
+
+
+def _check_output_size(result: Any, max_chars: int | None, tool_name: str) -> Any:
+    if max_chars is None or max_chars <= 0:
+        return result
+
+    try:
+        serialized = json.dumps(result, default=str)
+    except (TypeError, ValueError):
+        return result
+
+    if len(serialized) > max_chars:
+        truncated_preview = serialized[:500] + "..." if len(serialized) > 500 else serialized
+        _raise_output_too_large(
+            f"Tool '{tool_name}' output too large ({len(serialized):,} chars, limit {max_chars:,}). "
+            "Please narrow your query by: using the 'fields' parameter to select only needed fields, "
+            "adding filters, or reducing the 'limit'. "
+            f"Preview: {truncated_preview}"
+        )
+
+    return result
+
+
 
 
 class SlackConnector:
@@ -61,7 +107,7 @@ class SlackConnector:
     """
 
     connector_name = "slack"
-    connector_version = "0.1.5"
+    connector_version = "0.1.8"
     vendored_sdk_version = "0.1.0"  # Version of vendored connector-sdk
 
     # Map of (entity, action) -> needs_envelope for envelope wrapping decision
@@ -123,7 +169,7 @@ class SlackConnector:
                 Example: lambda tokens: save_to_database(tokens)
         Examples:
             # Local mode (direct API calls)
-            connector = SlackConnector(auth_config=SlackAuthConfig(access_token="..."))
+            connector = SlackConnector(auth_config=SlackAuthConfig(api_token="..."))
             # Hosted mode (executed on Airbyte cloud)
             connector = SlackConnector(
                 external_user_id="user-123",
@@ -303,15 +349,15 @@ class SlackConnector:
     async def execute(
         self,
         entity: str,
-        action: str,
-        params: dict[str, Any]
+        action: Literal["list", "get", "create", "update", "search"],
+        params: Mapping[str, Any]
     ) -> SlackExecuteResult[Any] | SlackExecuteResultWithMeta[Any, Any] | Any: ...
 
     async def execute(
         self,
         entity: str,
-        action: str,
-        params: dict[str, Any] | None = None
+        action: Literal["list", "get", "create", "update", "search"],
+        params: Mapping[str, Any] | None = None
     ) -> Any:
         """
         Execute an entity operation with full type safety.
@@ -339,16 +385,17 @@ class SlackConnector:
         from ._vendored.connector_sdk.executor import ExecutionConfig
 
         # Remap parameter names from snake_case (TypedDict keys) to API parameter names
-        if params:
+        resolved_params = dict(params) if params is not None else None
+        if resolved_params:
             param_map = self._PARAM_MAP.get((entity, action), {})
             if param_map:
-                params = {param_map.get(k, k): v for k, v in params.items()}
+                resolved_params = {param_map.get(k, k): v for k, v in resolved_params.items()}
 
         # Use ExecutionConfig for both local and hosted executors
         config = ExecutionConfig(
             entity=entity,
             action=action,
-            params=params
+            params=resolved_params
         )
 
         result = await self._executor.execute(config)
@@ -375,41 +422,67 @@ class SlackConnector:
     # ===== INTROSPECTION METHODS =====
 
     @classmethod
-    def describe(cls, func: _F) -> _F:
+    def tool_utils(
+        cls,
+        func: _F | None = None,
+        *,
+        update_docstring: bool = True,
+        max_output_chars: int | None = DEFAULT_MAX_OUTPUT_CHARS,
+    ) -> _F | Callable[[_F], _F]:
         """
-        Decorator that populates a function's docstring with connector capabilities.
-
-        This class method can be used as a decorator to automatically generate
-        comprehensive documentation for AI tool functions.
+        Decorator that adds tool utilities like docstring augmentation and output limits.
 
         Usage:
             @mcp.tool()
-            @SlackConnector.describe
+            @SlackConnector.tool_utils
             async def execute(entity: str, action: str, params: dict):
-                '''Execute operations.'''
                 ...
 
-        The decorated function's __doc__ will be updated with:
-        - Available entities and their actions
-        - Parameter signatures with required (*) and optional (?) markers
-        - Response structure documentation
-        - Example questions (if available in OpenAPI spec)
+            @mcp.tool()
+            @SlackConnector.tool_utils(update_docstring=False, max_output_chars=None)
+            async def execute(entity: str, action: str, params: dict):
+                ...
 
         Args:
-            func: The function to decorate
-
-        Returns:
-            The same function with updated __doc__
+            update_docstring: When True, append connector capabilities to __doc__.
+            max_output_chars: Max serialized output size before raising. Use None to disable.
         """
-        description = generate_tool_description(SlackConnectorModel)
 
-        original_doc = func.__doc__ or ""
-        if original_doc.strip():
-            func.__doc__ = f"{original_doc.strip()}\n{description}"
-        else:
-            func.__doc__ = description
+        def decorate(inner: _F) -> _F:
+            if update_docstring:
+                description = generate_tool_description(SlackConnectorModel)
+                original_doc = inner.__doc__ or ""
+                if original_doc.strip():
+                    full_doc = f"{original_doc.strip()}\n{description}"
+                else:
+                    full_doc = description
+            else:
+                full_doc = ""
+
+            if inspect.iscoroutinefunction(inner):
+
+                @wraps(inner)
+                async def aw(*args: Any, **kwargs: Any) -> Any:
+                    result = await inner(*args, **kwargs)
+                    return _check_output_size(result, max_output_chars, inner.__name__)
+
+                wrapped = aw
+            else:
+
+                @wraps(inner)
+                def sw(*args: Any, **kwargs: Any) -> Any:
+                    result = inner(*args, **kwargs)
+                    return _check_output_size(result, max_output_chars, inner.__name__)
+
+                wrapped = sw
+
+            if update_docstring:
+                wrapped.__doc__ = full_doc
+            return wrapped  # type: ignore[return-value]
 
-        return func
+        if func is not None:
+            return decorate(func)
+        return decorate
 
     def list_entities(self) -> list[dict[str, Any]]:
         """
@@ -522,6 +595,82 @@ class UsersQuery:
 
 
 
+    async def search(
+        self,
+        query: UsersSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> UsersSearchResult:
+        """
+        Search users records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (UsersSearchFilter):
+        - color: The color assigned to the user for visual purposes.
+        - deleted: Indicates if the user is deleted or not.
+        - has_2fa: Flag indicating if the user has two-factor authentication enabled.
+        - id: Unique identifier for the user.
+        - is_admin: Flag specifying if the user is an admin or not.
+        - is_app_user: Specifies if the user is an app user.
+        - is_bot: Indicates if the user is a bot account.
+        - is_email_confirmed: Flag indicating if the user's email is confirmed.
+        - is_forgotten: Specifies if the user is marked as forgotten.
+        - is_invited_user: Indicates if the user is invited or not.
+        - is_owner: Flag indicating if the user is an owner.
+        - is_primary_owner: Specifies if the user is the primary owner.
+        - is_restricted: Flag specifying if the user is restricted.
+        - is_ultra_restricted: Indicates if the user has ultra-restricted access.
+        - name: The username of the user.
+        - profile: User's profile information containing detailed details.
+        - real_name: The real name of the user.
+        - team_id: Unique identifier for the team the user belongs to.
+        - tz: Timezone of the user.
+        - tz_label: Label representing the timezone of the user.
+        - tz_offset: Offset of the user's timezone.
+        - updated: Timestamp of when the user's information was last updated.
+        - who_can_share_contact_card: Specifies who can share the user's contact card.
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            UsersSearchResult with hits (list of AirbyteSearchHit[UsersSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("users", "search", params)
+
+        # Parse response into typed result
+        return UsersSearchResult(
+            hits=[
+                AirbyteSearchHit[UsersSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=UsersSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
+
 class ChannelsQuery:
     """
     Query class for Channels entity operations.
@@ -650,6 +799,90 @@ class ChannelsQuery:
 
 
 
+    async def search(
+        self,
+        query: ChannelsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> ChannelsSearchResult:
+        """
+        Search channels records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (ChannelsSearchFilter):
+        - context_team_id: The unique identifier of the team context in which the channel exists.
+        - created: The timestamp when the channel was created.
+        - creator: The ID of the user who created the channel.
+        - id: The unique identifier of the channel.
+        - is_archived: Indicates if the channel is archived.
+        - is_channel: Indicates if the entity is a channel.
+        - is_ext_shared: Indicates if the channel is externally shared.
+        - is_general: Indicates if the channel is a general channel in the workspace.
+        - is_group: Indicates if the channel is a group (private channel) rather than a regular channel.
+        - is_im: Indicates if the entity is a direct message (IM) channel.
+        - is_member: Indicates if the calling user is a member of the channel.
+        - is_mpim: Indicates if the entity is a multiple person direct message (MPIM) channel.
+        - is_org_shared: Indicates if the channel is organization-wide shared.
+        - is_pending_ext_shared: Indicates if the channel is pending external shared.
+        - is_private: Indicates if the channel is a private channel.
+        - is_read_only: Indicates if the channel is read-only.
+        - is_shared: Indicates if the channel is shared.
+        - last_read: The timestamp of the user's last read message in the channel.
+        - locale: The locale of the channel.
+        - name: The name of the channel.
+        - name_normalized: The normalized name of the channel.
+        - num_members: The number of members in the channel.
+        - parent_conversation: The parent conversation of the channel.
+        - pending_connected_team_ids: The IDs of teams that are pending to be connected to the channel.
+        - pending_shared: The list of pending shared items of the channel.
+        - previous_names: The previous names of the channel.
+        - purpose: The purpose of the channel.
+        - shared_team_ids: The IDs of teams with which the channel is shared.
+        - topic: The topic of the channel.
+        - unlinked: Indicates if the channel is unlinked.
+        - updated: The timestamp when the channel was last updated.
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            ChannelsSearchResult with hits (list of AirbyteSearchHit[ChannelsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("channels", "search", params)
+
+        # Parse response into typed result
+        return ChannelsSearchResult(
+            hits=[
+                AirbyteSearchHit[ChannelsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=ChannelsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
+
 class ChannelMessagesQuery:
     """
     Query class for ChannelMessages entity operations.

airbyte_agent_slack/connector_model.py

@@ -27,7 +27,7 @@ from uuid import (
 SlackConnectorModel: ConnectorModel = ConnectorModel(
     id=UUID('c2281cee-86f9-4a86-bb48-d23286b4c7bd'),
     name='slack',
-    version='0.1.5',
+    version='0.1.8',
     base_url='https://slack.com/api',
     auth=AuthConfig(
         options=[
@@ -38,16 +38,16 @@ SlackConnectorModel: ConnectorModel = ConnectorModel(
                 user_config_spec=AirbyteAuthConfig(
                     title='Token Authentication',
                     type='object',
-                    required=['access_token'],
+                    required=['api_token'],
                     properties={
-                        'access_token': AuthConfigFieldSpec(
-                            title='Access Token',
+                        'api_token': AuthConfigFieldSpec(
+                            title='API Token',
                             description='Your Slack Bot Token (xoxb-) or User Token (xoxp-)',
                             airbyte_secret=True,
                         ),
                     },
-                    auth_mapping={'token': '${access_token}'},
-                    replication_auth_key_mapping={'credentials.api_token': 'access_token'},
+                    auth_mapping={'token': '${api_token}'},
+                    replication_auth_key_mapping={'credentials.api_token': 'api_token'},
                     replication_auth_key_constants={'credentials.option_title': 'API Token Credentials'},
                 ),
             ),
@@ -3192,4 +3192,104 @@ SlackConnectorModel: ConnectorModel = ConnectorModel(
             },
         ),
     ],
+    search_field_paths={
+        'channel_members': ['channel_id', 'member_id'],
+        'channels': [
+            'context_team_id',
+            'created',
+            'creator',
+            'id',
+            'is_archived',
+            'is_channel',
+            'is_ext_shared',
+            'is_general',
+            'is_group',
+            'is_im',
+            'is_member',
+            'is_mpim',
+            'is_org_shared',
+            'is_pending_ext_shared',
+            'is_private',
+            'is_read_only',
+            'is_shared',
+            'last_read',
+            'locale',
+            'name',
+            'name_normalized',
+            'num_members',
+            'parent_conversation',
+            'pending_connected_team_ids',
+            'pending_connected_team_ids[]',
+            'pending_shared',
+            'pending_shared[]',
+            'previous_names',
+            'previous_names[]',
+            'purpose',
+            'purpose.creator',
+            'purpose.last_set',
+            'purpose.value',
+            'shared_team_ids',
+            'shared_team_ids[]',
+            'topic',
+            'topic.creator',
+            'topic.last_set',
+            'topic.value',
+            'unlinked',
+            'updated',
+        ],
+        'users': [
+            'color',
+            'deleted',
+            'has_2fa',
+            'id',
+            'is_admin',
+            'is_app_user',
+            'is_bot',
+            'is_email_confirmed',
+            'is_forgotten',
+            'is_invited_user',
+            'is_owner',
+            'is_primary_owner',
+            'is_restricted',
+            'is_ultra_restricted',
+            'name',
+            'profile',
+            'profile.always_active',
+            'profile.avatar_hash',
+            'profile.display_name',
+            'profile.display_name_normalized',
+            'profile.email',
+            'profile.fields',
+            'profile.first_name',
+            'profile.huddle_state',
+            'profile.image_1024',
+            'profile.image_192',
+            'profile.image_24',
+            'profile.image_32',
+            'profile.image_48',
+            'profile.image_512',
+            'profile.image_72',
+            'profile.image_original',
+            'profile.last_name',
+            'profile.phone',
+            'profile.real_name',
+            'profile.real_name_normalized',
+            'profile.skype',
+            'profile.status_emoji',
+            'profile.status_emoji_display_info',
+            'profile.status_emoji_display_info[]',
+            'profile.status_expiration',
+            'profile.status_text',
+            'profile.status_text_canonical',
+            'profile.team',
+            'profile.title',
+            'real_name',
+            'team_id',
+            'tz',
+            'tz_label',
+            'tz_offset',
+            'updated',
+            'who_can_share_contact_card',
+        ],
+    },
 )