dao-ai 0.0.22__tar.gz → 0.0.23__tar.gz

{dao_ai-0.0.22 → dao_ai-0.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.22
+Version: 0.0.23
 Summary: DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML.
 Project-URL: Homepage, https://github.com/natefleming/dao-ai
 Project-URL: Documentation, https://natefleming.github.io/dao-ai
@@ -26,6 +26,7 @@ Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.12
 Requires-Dist: databricks-agents>=1.6.1
 Requires-Dist: databricks-langchain>=0.8.0
+Requires-Dist: databricks-mcp>=0.3.0
 Requires-Dist: databricks-sdk[openai]>=0.67.0
 Requires-Dist: duckduckgo-search>=8.0.2
 Requires-Dist: grandalf>=0.8
@@ -653,7 +654,7 @@ test:
 #### 4. MCP (Model Context Protocol) Tools (`type: mcp`)
    MCP tools allow interaction with external services that implement the Model Context Protocol, supporting both HTTP and stdio transports.
 
-   **Configuration Example:**
+   **Configuration Example (Direct URL):**
    ```yaml
    tools:
      weather_tool_mcp:
@@ -664,8 +665,30 @@ test:
          transport: streamable_http
          url: http://localhost:8000/mcp
    ```
+   
+   **Configuration Example (Unity Catalog Connection):**
+   MCP tools can also use Unity Catalog Connections for secure, governed access with on-behalf-of-user capabilities. The connection provides OAuth authentication, while the URL specifies the endpoint:
+   ```yaml
+   resources:
+     connections:
+       github_connection:
+         name: github_u2m_connection  # UC Connection name
+   
+   tools:
+     github_mcp:
+       name: github_mcp
+       function:
+         type: mcp
+         name: github_mcp
+         transport: streamable_http
+         url: https://workspace.databricks.com/api/2.0/mcp/external/github_u2m_connection  # MCP endpoint URL
+         connection: *github_connection  # UC Connection provides OAuth authentication
+   ```
+   
    **Development:**
-   Ensure the MCP service is running and accessible at the specified URL or command. The framework will handle the MCP protocol communication automatically.
+   - **For direct URL connections**: Ensure the MCP service is running and accessible at the specified URL or command. Provide OAuth credentials (client_id, client_secret) or PAT for authentication.
+   - **For UC Connection**: URL is required to specify the endpoint. The connection provides OAuth authentication via the workspace client. Ensure the connection is configured in Unity Catalog with appropriate MCP scopes (`mcp.genie`, `mcp.functions`, `mcp.vectorsearch`, `mcp.external`).
+   - The framework will handle the MCP protocol communication automatically, including session management and authentication.
 
 ### Configuring New Agents
 

{dao_ai-0.0.22 → dao_ai-0.0.23}/README.md

@@ -581,7 +581,7 @@ test:
 #### 4. MCP (Model Context Protocol) Tools (`type: mcp`)
    MCP tools allow interaction with external services that implement the Model Context Protocol, supporting both HTTP and stdio transports.
 
-   **Configuration Example:**
+   **Configuration Example (Direct URL):**
    ```yaml
    tools:
      weather_tool_mcp:
@@ -592,8 +592,30 @@ test:
          transport: streamable_http
          url: http://localhost:8000/mcp
    ```
+   
+   **Configuration Example (Unity Catalog Connection):**
+   MCP tools can also use Unity Catalog Connections for secure, governed access with on-behalf-of-user capabilities. The connection provides OAuth authentication, while the URL specifies the endpoint:
+   ```yaml
+   resources:
+     connections:
+       github_connection:
+         name: github_u2m_connection  # UC Connection name
+   
+   tools:
+     github_mcp:
+       name: github_mcp
+       function:
+         type: mcp
+         name: github_mcp
+         transport: streamable_http
+         url: https://workspace.databricks.com/api/2.0/mcp/external/github_u2m_connection  # MCP endpoint URL
+         connection: *github_connection  # UC Connection provides OAuth authentication
+   ```
+   
    **Development:**
-   Ensure the MCP service is running and accessible at the specified URL or command. The framework will handle the MCP protocol communication automatically.
+   - **For direct URL connections**: Ensure the MCP service is running and accessible at the specified URL or command. Provide OAuth credentials (client_id, client_secret) or PAT for authentication.
+   - **For UC Connection**: URL is required to specify the endpoint. The connection provides OAuth authentication via the workspace client. Ensure the connection is configured in Unity Catalog with appropriate MCP scopes (`mcp.genie`, `mcp.functions`, `mcp.vectorsearch`, `mcp.external`).
+   - The framework will handle the MCP protocol communication automatically, including session management and authentication.
 
 ### Configuring New Agents
 

dao_ai-0.0.23/config/examples/mcp_with_uc_connection.yaml

@@ -0,0 +1,109 @@
+# yaml-language-server: $schema=../../schemas/model_config_schema.json
+
+variables:
+  client_id: &client_id                          # Service principal client ID
+    options:
+      - env: RETAIL_AI_DATABRICKS_CLIENT_ID
+      - scope: retail_ai
+        secret: RETAIL_AI_DATABRICKS_CLIENT_ID
+  client_secret: &client_secret                  # Service principal secret
+    options:
+      - env: RETAIL_AI_DATABRICKS_CLIENT_SECRET
+      - scope: retail_ai
+        secret: RETAIL_AI_DATABRICKS_CLIENT_SECRET
+  workspace_host: &workspace_host                # Databricks workspace URL
+    options:
+      - env: RETAIL_AI_DATABRICKS_HOST
+      - scope: retail_ai
+        secret: RETAIL_AI_DATABRICKS_HOST
+
+schemas:
+  retail_schema: &retail_schema                  # Unity Catalog schema configuration
+    catalog_name: nfleming                       # Unity Catalog name
+    schema_name: retail_ai                       # Schema within the catalog
+
+resources:
+  llms:
+    default_llm: &default_llm                    # Default LLM configuration
+      name: databricks-claude-3-7-sonnet        # Databricks serving endpoint name
+  
+  connections:
+    github_connection: &github_connection       # UC Connection for GitHub
+      name: github_u2m_connection               # UC Connection name
+
+tools:
+  # Example using UC Connection for GitHub MCP
+  github_mcp_uc: &github_mcp_uc
+    name: github_mcp                                # Tool name for agent reference
+    function:
+      type: mcp                                     # Tool type: MCP server
+      name: github_mcp                              # MCP function name
+      transport: streamable_http                    # Transport protocol
+      url: https://adb-984752964297111.11.azuredatabricks.net/api/2.0/mcp/external/github_u2m_connection  # MCP endpoint URL
+      connection: *github_connection                # Reference to UC Connection (provides OAuth auth)
+
+  # Example using direct URL (existing approach)
+  weather_tool_mcp: &weather_tool_mcp
+    name: weather                                   # Tool name for agent reference
+    function:
+      type: mcp                                     # Tool type: MCP server
+      name: weather                                 # MCP function name
+      transport: streamable_http                    # Transport protocol
+      url: http://localhost:8000/mcp                # MCP server URL
+      
+  vector_search_mcp: &vector_search_mcp          # Vector search MCP tool configuration
+    name: vector_search_mcp                                  
+    function:
+      type: mcp                                  # MCP function type
+      name: vector_search_mcp                              
+      url: https://adb-984752964297111.11.azuredatabricks.net/api/2.0/mcp/vector-search/nfleming/retail_ai
+      client_id: *client_id
+      client_secret: *client_secret
+      workspace_host: *workspace_host
+
+  unity_catalog_mcp: &unity_catalog_mcp          # Unity Catalog MCP tool configuration
+    name: unity_catalog_mcp                                  
+    function:
+      type: mcp                                  # MCP function type
+      name: unity_catalog_mcp                              
+      url:  https://adb-984752964297111.11.azuredatabricks.net/api/2.0/mcp/functions/nfleming/retail_ai
+      client_id: *client_id
+      client_secret: *client_secret
+      workspace_host: *workspace_host
+
+  genie_mcp: &genie_mcp                          # Genie MCP tool configuration
+    name: genie_mcp                                  
+    function:
+      type: mcp                                  # MCP function type
+      name: genie_mcp                              
+      url:  https://adb-984752964297111.11.azuredatabricks.net/api/2.0/mcp/genie/01f01c91f1f414d59daaefd2b7ec82ea
+      client_id: *client_id
+      client_secret: *client_secret
+      workspace_host: *workspace_host
+
+agents:
+  mcp_agent: &mcp_agent                          # MCP agent configuration
+    name: mcp_agent                              # Agent identifier
+    model: *default_llm                          # Reference to LLM configuration
+    tools:                                       # Tools available to this agent
+      - *github_mcp_uc
+      - *vector_search_mcp
+      - *unity_catalog_mcp
+      - *genie_mcp
+    prompt: |                                    # System prompt defining agent behavior
+      You are a multi-purpose agent that can perform vector search, interact with Unity Catalog,
+      interact with Genie rooms, and interact with GitHub. Use the tools provided to answer 
+      questions and perform tasks. You many need to use the tools in combination to achieve 
+      complex tasks.
+      
+app:
+  name: mcp_agent                                # Application name  
+  log_level: DEBUG                               # Logging level for the application
+  registered_model:                              # MLflow registered model configuration
+    schema: *retail_schema                       # Schema where model will be registered
+    name: mcp_agent                              # Model name in MLflow registry
+  agents:                                        # List of agents included in the system
+    - *mcp_agent                                 # MCP agent
+  orchestration:                                 # Agent orchestration configuration
+    swarm:                                       # Supervisor orchestration pattern
+      model: *default_llm                        # LLM for routing decisions

dao_ai-0.0.23/config/examples/slack.yaml

@@ -0,0 +1,69 @@
+# yaml-language-server: $schema=../../schemas/model_config_schema.json
+
+schemas:
+  default_schema: &default_schema                   # Unity Catalog schema configuration
+    catalog_name: main                              # Unity Catalog name
+    schema_name: default                            # Schema within the catalog
+
+resources:
+  llms:
+    # Primary LLM for Slack agent
+    default_llm: &default_llm
+      name: databricks-meta-llama-3-3-70b-instruct  # Databricks serving endpoint name
+      temperature: 0.7                              # Temperature for more natural responses
+      max_tokens: 4096                              # Maximum tokens per response
+      on_behalf_of_user: false
+
+  connections:
+    # Unity Catalog HTTP connection to Slack
+    slack_connection: &slack_connection
+      name: slack_bot_connection                    # UC Connection name
+      on_behalf_of_user: false                      # Use service principal auth
+
+tools:
+  # Slack messaging tool using factory function
+  slack_tool: &slack_tool
+    name: send_slack_message                        # Tool name for agent reference
+    function:
+      type: factory                                 # Tool type: factory function
+      name: dao_ai.tools.create_send_slack_message_tool  # Factory function path
+      args:                                         # Arguments passed to factory
+        connection: *slack_connection               # Reference to Slack UC connection
+        channel_name: "general"                     # Slack channel name (can also use channel_id)
+        name: send_slack_message
+        description: Send a message to the #general Slack channel
+
+agents:
+  # Slack notification agent
+  slack_agent: &slack_agent
+    name: slack_agent                               # Agent identifier
+    description: "Agent that can send notifications to Slack"
+    model: *default_llm                             # Reference to LLM configuration
+    tools:                                          # Tools available to this agent
+      - *slack_tool
+    prompt: |                                       # System prompt defining agent behavior
+      You are a helpful assistant that can send notifications to Slack.
+      When asked to notify someone or send a message, use the send_slack_message tool
+      to post to the #general channel. Keep messages concise and professional.
+
+app:
+  name: slack_agent_example                         # Application name  
+  description: "Agent system that can send notifications to Slack"
+  log_level: INFO                                   # Logging level for the application
+  registered_model:                                 # MLflow registered model configuration
+    schema: *default_schema                         # Schema where model will be registered
+    name: slack_notification_agent                  # Model name in MLflow registry
+  endpoint_name: slack_notification_agent           # Model serving endpoint name
+  tags:                                             # Tags for resource organization
+    integration: slack                              # Integration type
+    notification: true                              # Indicates notification capabilities
+  permissions:                                      # Model serving permissions
+    - principals: [users]                           # Grant access to all users
+      entitlements:
+        - CAN_QUERY                                 # Query permissions
+  agents:                                           # List of agents included in the system
+    - *slack_agent                                  # Slack notification agent
+  orchestration:                                    # Agent orchestration configuration
+    swarm:                                          # Swarm orchestration pattern
+      model: *default_llm                           # LLM for routing decisions
+

{dao_ai-0.0.22 → dao_ai-0.0.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dao-ai"
-version = "0.0.22"
+version = "0.0.23"
 description = "DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML."
 readme = "README.md"
 license = { text = "MIT" }
@@ -44,6 +44,7 @@ classifiers = [
 dependencies = [
     "databricks-agents>=1.6.1",
     "databricks-langchain>=0.8.0",
+    "databricks-mcp>=0.3.0",
     "databricks-sdk[openai]>=0.67.0",
     "duckduckgo-search>=8.0.2",
     "grandalf>=0.8",

{dao_ai-0.0.22 → dao_ai-0.0.23}/requirements.txt

@@ -25,6 +25,7 @@ cyclopts==3.24.0
 databricks-agents==1.6.1
 databricks-ai-bridge==0.8.0
 databricks-langchain==0.8.0
+databricks-mcp==0.3.0
 databricks-sdk==0.67.0
 dataclasses-json==0.6.7
 deprecation==2.1.0

{dao_ai-0.0.22 → dao_ai-0.0.23}/schemas/model_config_schema.json

@@ -1677,6 +1677,17 @@
           "default": null,
           "title": "Url"
         },
+        "connection": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/ConnectionModel"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null
+        },
         "headers": {
           "additionalProperties": {
             "anyOf": [

{dao_ai-0.0.22 → dao_ai-0.0.23}/src/dao_ai/config.py

@@ -666,6 +666,10 @@ class ConnectionModel(BaseModel, HasFullName, IsDatabricksResource):
         return [
             "catalog.connections",
             "serving.serving-endpoints",
+            "mcp.genie",
+            "mcp.functions",
+            "mcp.vectorsearch",
+            "mcp.external",
         ]
 
     def as_resources(self) -> Sequence[DatabricksResource]:
@@ -988,6 +992,7 @@ class McpFunctionModel(BaseFunctionModel, HasFullName):
     transport: TransportType = TransportType.STREAMABLE_HTTP
     command: Optional[str] = "python"
     url: Optional[AnyVariable] = None
+    connection: Optional[ConnectionModel] = None
     headers: dict[str, AnyVariable] = Field(default_factory=dict)
     args: list[str] = Field(default_factory=list)
     pat: Optional[AnyVariable] = None

{dao_ai-0.0.22 → dao_ai-0.0.23}/src/dao_ai/tools/__init__.py

@@ -7,6 +7,7 @@ from dao_ai.tools.core import (
 from dao_ai.tools.genie import create_genie_tool
 from dao_ai.tools.mcp import create_mcp_tools
 from dao_ai.tools.python import create_factory_tool, create_python_tool
+from dao_ai.tools.slack import create_send_slack_message_tool
 from dao_ai.tools.time import (
     add_time_tool,
     current_time_tool,
@@ -27,6 +28,7 @@ __all__ = [
     "create_hooks",
     "create_mcp_tools",
     "create_python_tool",
+    "create_send_slack_message_tool",
     "create_tools",
     "create_uc_tools",
     "create_vector_search_tool",

dao_ai-0.0.23/src/dao_ai/tools/mcp.py

@@ -0,0 +1,164 @@
+import asyncio
+from typing import Any, Sequence
+
+from databricks_mcp import DatabricksOAuthClientProvider
+from langchain_core.runnables.base import RunnableLike
+from langchain_core.tools import tool as create_tool
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_mcp_adapters.tools import load_mcp_tools
+from loguru import logger
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+from mcp.types import ListToolsResult, Tool
+
+from dao_ai.config import (
+    McpFunctionModel,
+    TransportType,
+)
+from dao_ai.tools.human_in_the_loop import as_human_in_the_loop
+
+
+def create_mcp_tools(
+    function: McpFunctionModel,
+) -> Sequence[RunnableLike]:
+    """
+    Create tools for invoking Databricks MCP functions.
+
+    Supports both direct MCP connections and UC Connection-based MCP access.
+    Uses session-based approach to handle authentication token expiration properly.
+
+    Based on: https://docs.databricks.com/aws/en/generative-ai/mcp/external-mcp
+    """
+    logger.debug(f"create_mcp_tools: {function}")
+
+    # Check if using UC Connection or direct MCP connection
+    if function.connection:
+        # Use UC Connection approach with DatabricksOAuthClientProvider
+        logger.debug(f"Using UC Connection for MCP: {function.connection.name}")
+        logger.debug(f"MCP URL: {function.url}")
+
+        async def _get_tools_with_connection():
+            """Get tools using DatabricksOAuthClientProvider."""
+            workspace_client = function.connection.workspace_client
+
+            async with streamablehttp_client(
+                function.url, auth=DatabricksOAuthClientProvider(workspace_client)
+            ) as (read_stream, write_stream, _):
+                async with ClientSession(read_stream, write_stream) as session:
+                    # Initialize and list tools
+                    await session.initialize()
+                    tools = await load_mcp_tools(session)
+                    return tools
+
+        try:
+            langchain_tools = asyncio.run(_get_tools_with_connection())
+            logger.debug(
+                f"Retrieved {len(langchain_tools)} MCP tools via UC Connection"
+            )
+
+            # Wrap tools with human-in-the-loop if needed
+            wrapped_tools = [
+                as_human_in_the_loop(tool, function) for tool in langchain_tools
+            ]
+            return wrapped_tools
+
+        except Exception as e:
+            logger.error(f"Failed to get tools from MCP server via UC Connection: {e}")
+            raise RuntimeError(
+                f"Failed to list MCP tools for function '{function.name}' via UC Connection '{function.connection.name}': {e}"
+            )
+
+    else:
+        # Use direct MCP connection with MultiServerMCPClient
+        logger.debug("Using direct MCP connection with MultiServerMCPClient")
+
+        def _create_fresh_connection() -> dict[str, Any]:
+            """Create connection config with fresh authentication headers."""
+            logger.debug("Creating fresh connection...")
+
+            if function.transport == TransportType.STDIO:
+                return {
+                    "command": function.command,
+                    "args": function.args,
+                    "transport": function.transport,
+                }
+
+            # For HTTP transport, generate fresh headers
+            headers = function.headers.copy() if function.headers else {}
+
+            if "Authorization" not in headers:
+                logger.debug("Generating fresh authentication token for MCP function")
+
+                from dao_ai.config import value_of
+                from dao_ai.providers.databricks import DatabricksProvider
+
+                try:
+                    provider = DatabricksProvider(
+                        workspace_host=value_of(function.workspace_host),
+                        client_id=value_of(function.client_id),
+                        client_secret=value_of(function.client_secret),
+                        pat=value_of(function.pat),
+                    )
+                    headers["Authorization"] = f"Bearer {provider.create_token()}"
+                    logger.debug("Generated fresh authentication token")
+                except Exception as e:
+                    logger.error(f"Failed to create fresh token: {e}")
+            else:
+                logger.debug("Using existing authentication token")
+
+            return {
+                "url": function.url,
+                "transport": function.transport,
+                "headers": headers,
+            }
+
+        # Get available tools from MCP server
+        async def _list_mcp_tools():
+            connection = _create_fresh_connection()
+            client = MultiServerMCPClient({function.name: connection})
+
+            try:
+                async with client.session(function.name) as session:
+                    return await session.list_tools()
+            except Exception as e:
+                logger.error(f"Failed to list MCP tools: {e}")
+                return []
+
+        # Note: This still needs to run sync during tool creation/registration
+        # The actual tool execution will be async
+        try:
+            mcp_tools: list[Tool] | ListToolsResult = asyncio.run(_list_mcp_tools())
+            if isinstance(mcp_tools, ListToolsResult):
+                mcp_tools = mcp_tools.tools
+
+            logger.debug(f"Retrieved {len(mcp_tools)} MCP tools")
+        except Exception as e:
+            logger.error(f"Failed to get tools from MCP server: {e}")
+            raise RuntimeError(
+                f"Failed to list MCP tools for function '{function.name}' with transport '{function.transport}' and URL '{function.url}': {e}"
+            )
+
+        # Create wrapper tools with fresh session per invocation
+        def _create_tool_wrapper(mcp_tool: Tool) -> RunnableLike:
+            @create_tool(
+                mcp_tool.name,
+                description=mcp_tool.description or f"MCP tool: {mcp_tool.name}",
+                args_schema=mcp_tool.inputSchema,
+            )
+            async def tool_wrapper(**kwargs):
+                """Execute MCP tool with fresh session and authentication."""
+                logger.debug(f"Invoking MCP tool {mcp_tool.name} with fresh session")
+
+                connection = _create_fresh_connection()
+                client = MultiServerMCPClient({function.name: connection})
+
+                try:
+                    async with client.session(function.name) as session:
+                        return await session.call_tool(mcp_tool.name, kwargs)
+                except Exception as e:
+                    logger.error(f"MCP tool {mcp_tool.name} failed: {e}")
+                    raise
+
+            return as_human_in_the_loop(tool_wrapper, function)
+
+        return [_create_tool_wrapper(tool) for tool in mcp_tools]

dao_ai-0.0.23/src/dao_ai/tools/slack.py

@@ -0,0 +1,136 @@
+from typing import Any, Callable, Optional
+
+from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod
+from langchain_core.tools import tool
+from loguru import logger
+from requests import Response
+
+from dao_ai.config import ConnectionModel
+
+
+def _find_channel_id_by_name(
+    connection: ConnectionModel, channel_name: str
+) -> Optional[str]:
+    """
+    Find a Slack channel ID by channel name using the conversations.list API.
+
+    Based on: https://docs.databricks.com/aws/en/generative-ai/agent-framework/slack-agent
+
+    Args:
+        connection: ConnectionModel with workspace_client
+        channel_name: Name of the Slack channel (with or without '#' prefix)
+
+    Returns:
+        Channel ID if found, None otherwise
+    """
+    # Remove '#' prefix if present
+    clean_name = channel_name.lstrip("#")
+
+    logger.debug(f"Looking up Slack channel ID for channel name: {clean_name}")
+
+    try:
+        # Call Slack API to list conversations
+        response: Response = connection.workspace_client.serving_endpoints.http_request(
+            conn=connection.name,
+            method=ExternalFunctionRequestHttpMethod.GET,
+            path="/api/conversations.list",
+        )
+
+        if response.status_code != 200:
+            logger.error(f"Failed to list Slack channels: {response.text}")
+            return None
+
+        # Parse response
+        data = response.json()
+
+        if not data.get("ok"):
+            logger.error(f"Slack API returned error: {data.get('error')}")
+            return None
+
+        # Search for channel by name
+        channels = data.get("channels", [])
+        for channel in channels:
+            if channel.get("name") == clean_name:
+                channel_id = channel.get("id")
+                logger.debug(
+                    f"Found channel ID '{channel_id}' for channel name '{clean_name}'"
+                )
+                return channel_id
+
+        logger.warning(f"Channel '{clean_name}' not found in Slack workspace")
+        return None
+
+    except Exception as e:
+        logger.error(f"Error looking up Slack channel: {e}")
+        return None
+
+
+def create_send_slack_message_tool(
+    connection: ConnectionModel | dict[str, Any],
+    channel_id: Optional[str] = None,
+    channel_name: Optional[str] = None,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+) -> Callable[[str], Any]:
+    """
+    Create a tool that sends a message to a Slack channel.
+
+    Args:
+        connection: Unity Catalog connection to Slack (ConnectionModel or dict)
+        channel_id: Slack channel ID (e.g., 'C1234567890'). If not provided, channel_name is used.
+        channel_name: Slack channel name (e.g., 'general' or '#general'). Used to lookup channel_id if not provided.
+        name: Custom tool name (default: 'send_slack_message')
+        description: Custom tool description
+
+    Returns:
+        A tool function that sends messages to the specified Slack channel
+
+    Based on: https://docs.databricks.com/aws/en/generative-ai/agent-framework/slack-agent
+    """
+    logger.debug("create_send_slack_message_tool")
+
+    # Validate inputs
+    if channel_id is None and channel_name is None:
+        raise ValueError("Either channel_id or channel_name must be provided")
+
+    # Convert connection dict to ConnectionModel if needed
+    if isinstance(connection, dict):
+        connection = ConnectionModel(**connection)
+
+    # Look up channel_id from channel_name if needed
+    if channel_id is None and channel_name is not None:
+        logger.debug(f"Looking up channel_id for channel_name: {channel_name}")
+        channel_id = _find_channel_id_by_name(connection, channel_name)
+        if channel_id is None:
+            raise ValueError(f"Could not find Slack channel with name '{channel_name}'")
+        logger.debug(
+            f"Resolved channel_name '{channel_name}' to channel_id '{channel_id}'"
+        )
+
+    if name is None:
+        name = "send_slack_message"
+
+    if description is None:
+        description = "Send a message to a Slack channel"
+
+    @tool(
+        name_or_callable=name,
+        description=description,
+    )
+    def send_slack_message(text: str) -> str:
+        response: Response = connection.workspace_client.serving_endpoints.http_request(
+            conn=connection.name,
+            method=ExternalFunctionRequestHttpMethod.POST,
+            path="/api/chat.postMessage",
+            json={"channel": channel_id, "text": text},
+        )
+
+        if response.status_code == 200:
+            return "Successful request sent to Slack: " + response.text
+        else:
+            return (
+                "Encountered failure when executing request. Message from Call: "
+                + response.text
+            )
+
+    return send_slack_message