dao-ai 0.1.2__py3-none-any.whl → 0.1.20__py3-none-any.whl

dao_ai/cli.py

@@ -2,12 +2,13 @@ import argparse
 import getpass
 import json
 import os
+import signal
 import subprocess
 import sys
 import traceback
 from argparse import ArgumentParser, Namespace
 from pathlib import Path
-from typing import Optional, Sequence
+from typing import Any, Optional, Sequence
 
 from dotenv import find_dotenv, load_dotenv
 from loguru import logger
@@ -47,6 +48,68 @@ def get_default_user_id() -> str:
         return local_user
 
 
+def detect_cloud_provider(profile: Optional[str] = None) -> Optional[str]:
+    """
+    Detect the cloud provider from the Databricks workspace URL.
+
+    The cloud provider is determined by the workspace URL pattern:
+    - Azure: *.azuredatabricks.net
+    - AWS: *.cloud.databricks.com (without gcp subdomain)
+    - GCP: *.gcp.databricks.com
+
+    Args:
+        profile: Optional Databricks CLI profile name
+
+    Returns:
+        Cloud provider string ('azure', 'aws', 'gcp') or None if detection fails
+    """
+    try:
+        import os
+
+        from databricks.sdk import WorkspaceClient
+
+        # Check for environment variables that might override profile
+        if profile and os.environ.get("DATABRICKS_HOST"):
+            logger.warning(
+                f"DATABRICKS_HOST environment variable is set, which may override --profile {profile}"
+            )
+
+        # Create workspace client with optional profile
+        if profile:
+            logger.debug(f"Creating WorkspaceClient with profile: {profile}")
+            w = WorkspaceClient(profile=profile)
+        else:
+            logger.debug("Creating WorkspaceClient with default/ambient credentials")
+            w = WorkspaceClient()
+
+        # Get the workspace URL from config
+        host = w.config.host
+        logger.debug(f"WorkspaceClient host: {host}, profile used: {profile}")
+        if not host:
+            logger.warning("Could not determine workspace URL for cloud detection")
+            return None
+
+        host_lower = host.lower()
+
+        if "azuredatabricks.net" in host_lower:
+            logger.debug(f"Detected Azure cloud from workspace URL: {host}")
+            return "azure"
+        elif ".gcp.databricks.com" in host_lower:
+            logger.debug(f"Detected GCP cloud from workspace URL: {host}")
+            return "gcp"
+        elif ".cloud.databricks.com" in host_lower or "databricks.com" in host_lower:
+            # AWS uses *.cloud.databricks.com or regional patterns
+            logger.debug(f"Detected AWS cloud from workspace URL: {host}")
+            return "aws"
+        else:
+            logger.warning(f"Could not determine cloud provider from URL: {host}")
+            return None
+
+    except Exception as e:
+        logger.warning(f"Could not detect cloud provider: {e}")
+        return None
+
+
 env_path: str = find_dotenv()
 if env_path:
     logger.info(f"Loading environment variables from: {env_path}")
@@ -63,6 +126,7 @@ Examples:
   dao-ai validate -c config/model_config.yaml            # Validate a specific configuration file
   dao-ai graph -o architecture.png -c my_config.yaml -v  # Generate visual graph with verbose output
   dao-ai chat -c config/retail.yaml --custom-input store_num=87887  # Start interactive chat session
+  dao-ai list-mcp-tools -c config/mcp_config.yaml --apply-filters  # List filtered MCP tools only
   dao-ai validate                                        # Validate with detailed logging
   dao-ai bundle --deploy                                 # Deploy the DAO AI asset bundle
         """,
@@ -220,12 +284,28 @@ Examples:
         "-t",
         "--target",
         type=str,
+        help="Bundle target name (default: auto-generated from app name and cloud)",
+    )
+    bundle_parser.add_argument(
+        "--cloud",
+        type=str,
+        choices=["azure", "aws", "gcp"],
+        help="Cloud provider (auto-detected from workspace URL if not specified)",
     )
     bundle_parser.add_argument(
         "--dry-run",
         action="store_true",
         help="Perform a dry run without executing the deployment or run commands",
     )
+    bundle_parser.add_argument(
+        "--deployment-target",
+        type=str,
+        choices=["model_serving", "apps"],
+        default=None,
+        help="Agent deployment target: 'model_serving' or 'apps'. "
+        "If not specified, uses app.deployment_target from config file, "
+        "or defaults to 'model_serving'. Passed to the deploy notebook.",
+    )
 
     # Deploy command
     deploy_parser: ArgumentParser = subparsers.add_parser(
@@ -250,6 +330,63 @@ Examples:
         metavar="FILE",
         help="Path to the model configuration file to validate",
     )
+    deploy_parser.add_argument(
+        "-t",
+        "--target",
+        type=str,
+        choices=["model_serving", "apps"],
+        default=None,
+        help="Deployment target: 'model_serving' or 'apps'. "
+        "If not specified, uses app.deployment_target from config file, "
+        "or defaults to 'model_serving'.",
+    )
+
+    # List MCP tools command
+    list_mcp_parser: ArgumentParser = subparsers.add_parser(
+        "list-mcp-tools",
+        help="List available MCP tools from configuration",
+        description="""
+List all available MCP tools from the configured MCP servers.
+This command shows:
+- All MCP servers/functions in the configuration
+- Available tools from each server
+- Full descriptions for each tool (no truncation)
+- Tool parameters in readable format (type, required/optional, descriptions)
+- Which tools are included/excluded based on filters
+- Filter patterns (include_tools, exclude_tools)
+
+Use this command to:
+- Discover available tools before configuring agents
+- Review tool descriptions and parameter schemas
+- Debug tool filtering configuration
+- Verify MCP server connectivity
+
+Options:
+- Use --apply-filters to only show tools that will be loaded (hides excluded tools)
+- Without --apply-filters, see all available tools with include/exclude status
+
+Note: Schemas are displayed in a concise, readable format instead of verbose JSON
+        """,
+        epilog="""Examples:
+  dao-ai list-mcp-tools -c config/model_config.yaml
+  dao-ai list-mcp-tools -c config/model_config.yaml --apply-filters
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    list_mcp_parser.add_argument(
+        "-c",
+        "--config",
+        type=str,
+        default="./config/model_config.yaml",
+        required=False,
+        metavar="FILE",
+        help="Path to the model configuration file (default: ./config/model_config.yaml)",
+    )
+    list_mcp_parser.add_argument(
+        "--apply-filters",
+        action="store_true",
+        help="Only show tools that pass include/exclude filters (hide excluded tools)",
+    )
 
     chat_parser: ArgumentParser = subparsers.add_parser(
         "chat",
@@ -318,6 +455,18 @@ def handle_chat_command(options: Namespace) -> None:
     """Interactive chat REPL with the DAO AI system with Human-in-the-Loop support."""
     logger.debug("Starting chat session with DAO AI system...")
 
+    # Set up signal handler for clean Ctrl+C handling
+    def signal_handler(sig: int, frame: Any) -> None:
+        try:
+            print("\n\n👋 Chat session interrupted. Goodbye!")
+            sys.stdout.flush()
+        except Exception:
+            pass
+        sys.exit(0)
+
+    # Store original handler and set our handler
+    original_handler = signal.signal(signal.SIGINT, signal_handler)
+
     try:
         # Set default user_id if not provided
         if options.user_id is None:
@@ -385,14 +534,19 @@ def handle_chat_command(options: Namespace) -> None:
                             )
                             continue
 
+                # Normalize user_id for memory namespace compatibility (replace . with _)
+                # This matches the normalization in models.py _convert_to_context
+                if configurable.get("user_id"):
+                    configurable["user_id"] = configurable["user_id"].replace(".", "_")
+
                 # Create Context object from configurable dict
                 from dao_ai.state import Context
 
                 context = Context(**configurable)
 
-                # Prepare config with thread_id for checkpointer
-                # Note: thread_id is needed in config for checkpointer/memory
-                config = {"configurable": {"thread_id": options.thread_id}}
+                # Prepare config with all context fields for checkpointer/memory
+                # Note: langmem tools require user_id in config.configurable for namespace resolution
+                config = {"configurable": context.model_dump()}
 
                 # Invoke the graph and handle interrupts (HITL)
                 # Wrap in async function to maintain connection pool throughout
@@ -526,6 +680,12 @@ def handle_chat_command(options: Namespace) -> None:
 
                 try:
                     result = loop.run_until_complete(_invoke_with_hitl())
+                except KeyboardInterrupt:
+                    # Re-raise to be caught by outer handler
+                    raise
+                except asyncio.CancelledError:
+                    # Treat cancellation like KeyboardInterrupt
+                    raise KeyboardInterrupt
                 except Exception as e:
                     logger.error(f"Error invoking graph: {e}")
                     print(f"\n❌ Error: {e}")
@@ -549,13 +709,6 @@ def handle_chat_command(options: Namespace) -> None:
                         # Find the last AI message
                         for msg in reversed(latest_messages):
                             if isinstance(msg, AIMessage):
-                                logger.debug(f"AI message content: {msg.content}")
-                                logger.debug(
-                                    f"AI message has tool_calls: {hasattr(msg, 'tool_calls')}"
-                                )
-                                if hasattr(msg, "tool_calls"):
-                                    logger.debug(f"Tool calls: {msg.tool_calls}")
-
                                 if hasattr(msg, "content") and msg.content:
                                     response_content = msg.content
                                     print(response_content, end="", flush=True)
@@ -598,23 +751,34 @@ def handle_chat_command(options: Namespace) -> None:
                     logger.error(f"Response processing error: {e}")
                     logger.error(f"Stack trace: {traceback.format_exc()}")
 
-            except EOFError:
-                # Handle Ctrl-D
-                print("\n\n👋 Goodbye! Chat session ended.")
-                break
-            except KeyboardInterrupt:
-                # Handle Ctrl-C
-                print("\n\n👋 Chat session interrupted. Goodbye!")
+            except (EOFError, KeyboardInterrupt):
+                # Handle Ctrl-D (EOF) or Ctrl-C (interrupt)
+                # Use try/except for print in case stdout is closed
+                try:
+                    print("\n\n👋 Goodbye! Chat session ended.")
+                    sys.stdout.flush()
+                except Exception:
+                    pass
                 break
             except Exception as e:
                 print(f"\n❌ Error: {e}")
                 logger.error(f"Chat error: {e}")
                 traceback.print_exc()
 
+    except (EOFError, KeyboardInterrupt):
+        # Handle interrupts during initialization
+        try:
+            print("\n\n👋 Chat session interrupted. Goodbye!")
+            sys.stdout.flush()
+        except Exception:
+            pass
     except Exception as e:
         logger.error(f"Failed to initialize chat session: {e}")
         print(f"❌ Failed to start chat session: {e}")
         sys.exit(1)
+    finally:
+        # Restore original signal handler
+        signal.signal(signal.SIGINT, original_handler)
 
 
 def handle_schema_command(options: Namespace) -> None:
@@ -630,11 +794,28 @@ def handle_graph_command(options: Namespace) -> None:
 
 
 def handle_deploy_command(options: Namespace) -> None:
+    from dao_ai.config import DeploymentTarget
+
     logger.debug(f"Validating configuration from {options.config}...")
     try:
         config: AppConfig = AppConfig.from_file(options.config)
+
+        # Hybrid target resolution:
+        # 1. CLI --target takes precedence
+        # 2. Fall back to config.app.deployment_target
+        # 3. Default to MODEL_SERVING (handled in deploy_agent)
+        target: DeploymentTarget | None = None
+        if options.target is not None:
+            target = DeploymentTarget(options.target)
+            logger.info(f"Using CLI-specified deployment target: {target.value}")
+        elif config.app is not None and config.app.deployment_target is not None:
+            target = config.app.deployment_target
+            logger.info(f"Using config file deployment target: {target.value}")
+        else:
+            logger.info("No deployment target specified, defaulting to model_serving")
+
         config.create_agent()
-        config.deploy_agent()
+        config.deploy_agent(target=target)
         sys.exit(0)
     except Exception as e:
         logger.error(f"Deployment failed: {e}")
@@ -653,6 +834,275 @@ def handle_validate_command(options: Namespace) -> None:
         sys.exit(1)
 
 
+def _format_schema_pretty(schema: dict[str, Any], indent: int = 0) -> str:
+    """
+    Format a JSON schema in a more readable, concise format.
+
+    Args:
+        schema: The JSON schema to format
+        indent: Current indentation level
+
+    Returns:
+        Pretty-formatted schema string
+    """
+    if not schema:
+        return ""
+
+    lines: list[str] = []
+    indent_str = "  " * indent
+
+    # Get required fields
+    required_fields = set(schema.get("required", []))
+
+    # Handle object type with properties
+    if schema.get("type") == "object" and "properties" in schema:
+        properties = schema["properties"]
+
+        for prop_name, prop_schema in properties.items():
+            is_required = prop_name in required_fields
+            req_marker = " (required)" if is_required else " (optional)"
+
+            prop_type = prop_schema.get("type", "any")
+            prop_desc = prop_schema.get("description", "")
+
+            # Handle different types
+            if prop_type == "array":
+                items = prop_schema.get("items", {})
+                item_type = items.get("type", "any")
+                type_str = f"array<{item_type}>"
+            elif prop_type == "object":
+                type_str = "object"
+            else:
+                type_str = prop_type
+
+            # Format enum values if present
+            if "enum" in prop_schema:
+                enum_values = ", ".join(str(v) for v in prop_schema["enum"])
+                type_str = f"{type_str} (one of: {enum_values})"
+
+            # Build the line
+            line = f"{indent_str}{prop_name}: {type_str}{req_marker}"
+            if prop_desc:
+                line += f"\n{indent_str}  └─ {prop_desc}"
+
+            lines.append(line)
+
+            # Recursively handle nested objects
+            if prop_type == "object" and "properties" in prop_schema:
+                nested = _format_schema_pretty(prop_schema, indent + 1)
+                if nested:
+                    lines.append(nested)
+
+    # Handle simple types without properties
+    elif "type" in schema:
+        schema_type = schema["type"]
+        if schema.get("description"):
+            lines.append(f"{indent_str}Type: {schema_type}")
+            lines.append(f"{indent_str}└─ {schema['description']}")
+        else:
+            lines.append(f"{indent_str}Type: {schema_type}")
+
+    return "\n".join(lines)
+
+
+def handle_list_mcp_tools_command(options: Namespace) -> None:
+    """
+    List available MCP tools from configuration.
+
+    Shows all MCP servers and their available tools, indicating which
+    are included/excluded based on filter configuration.
+    """
+    logger.debug(f"Listing MCP tools from configuration: {options.config}")
+
+    try:
+        from dao_ai.config import McpFunctionModel
+        from dao_ai.tools.mcp import MCPToolInfo, _matches_pattern, list_mcp_tools
+
+        # Load configuration
+        config: AppConfig = AppConfig.from_file(options.config)
+
+        # Find all MCP tools in configuration
+        mcp_tools_config: list[tuple[str, McpFunctionModel]] = []
+        if config.tools:
+            for tool_name, tool_model in config.tools.items():
+                logger.debug(
+                    f"Checking tool: {tool_name}, function type: {type(tool_model.function)}"
+                )
+                if tool_model.function and isinstance(
+                    tool_model.function, McpFunctionModel
+                ):
+                    mcp_tools_config.append((tool_name, tool_model.function))
+
+        if not mcp_tools_config:
+            logger.warning("No MCP tools found in configuration")
+            print("\n⚠️  No MCP tools configured in this file.")
+            print(f"   Configuration: {options.config}")
+            print(
+                "\nTo add MCP tools, define them in the 'tools' section with 'type: mcp'"
+            )
+            sys.exit(0)
+
+        # Collect all results first (aggregate before displaying)
+        results: list[dict[str, Any]] = []
+        for tool_name, mcp_function in mcp_tools_config:
+            result = {
+                "tool_name": tool_name,
+                "mcp_function": mcp_function,
+                "error": None,
+                "all_tools": [],
+                "included_tools": [],
+                "excluded_tools": [],
+            }
+
+            try:
+                logger.info(f"Connecting to MCP server: {mcp_function.mcp_url}")
+
+                # Get all available tools (unfiltered)
+                all_tools: list[MCPToolInfo] = list_mcp_tools(
+                    mcp_function, apply_filters=False
+                )
+
+                # Get filtered tools (what will actually be loaded)
+                filtered_tools: list[MCPToolInfo] = list_mcp_tools(
+                    mcp_function, apply_filters=True
+                )
+
+                included_names = {t.name for t in filtered_tools}
+
+                # Categorize tools
+                for tool in sorted(all_tools, key=lambda t: t.name):
+                    if tool.name in included_names:
+                        result["included_tools"].append(tool)
+                    else:
+                        # Determine why it was excluded
+                        reason = ""
+                        if mcp_function.exclude_tools:
+                            if _matches_pattern(tool.name, mcp_function.exclude_tools):
+                                matching_patterns = [
+                                    p
+                                    for p in mcp_function.exclude_tools
+                                    if _matches_pattern(tool.name, [p])
+                                ]
+                                reason = f" (matches exclude pattern: {', '.join(matching_patterns)})"
+                        if not reason and mcp_function.include_tools:
+                            reason = " (not in include list)"
+                        result["excluded_tools"].append((tool, reason))
+
+                result["all_tools"] = all_tools
+
+            except KeyboardInterrupt:
+                result["error"] = "Connection interrupted by user"
+                results.append(result)
+                break
+            except Exception as e:
+                logger.error(f"Failed to list tools from MCP server: {e}")
+                result["error"] = str(e)
+
+            results.append(result)
+
+        # Now display all results at once (no logging interleaving)
+        print(f"\n{'=' * 80}")
+        print("MCP TOOLS DISCOVERY")
+        print(f"Configuration: {options.config}")
+        print(f"{'=' * 80}\n")
+
+        for result in results:
+            tool_name = result["tool_name"]
+            mcp_function = result["mcp_function"]
+
+            print(f"📦 Tool: {tool_name}")
+            print(f"   Server: {mcp_function.mcp_url}")
+
+            # Show connection type
+            if mcp_function.connection:
+                print(f"   Connection: UC Connection '{mcp_function.connection.name}'")
+            else:
+                print(f"   Transport: {mcp_function.transport.value}")
+
+            # Show filters if configured
+            if mcp_function.include_tools or mcp_function.exclude_tools:
+                print("\n   Filters:")
+                if mcp_function.include_tools:
+                    print(f"     Include: {', '.join(mcp_function.include_tools)}")
+                if mcp_function.exclude_tools:
+                    print(f"     Exclude: {', '.join(mcp_function.exclude_tools)}")
+
+            # Check for errors
+            if result["error"]:
+                print(f"\n   ❌ Error: {result['error']}")
+                print("   Could not connect to MCP server")
+                if result["error"] != "Connection interrupted by user":
+                    print(
+                        "   Tip: Verify server URL, authentication, and network connectivity"
+                    )
+            else:
+                all_tools = result["all_tools"]
+                included_tools = result["included_tools"]
+                excluded_tools = result["excluded_tools"]
+
+                # Show stats based on --apply-filters flag
+                if options.apply_filters:
+                    # Simplified view: only show filtered tools count
+                    print(
+                        f"\n   Available Tools: {len(included_tools)} (after filters)"
+                    )
+                else:
+                    # Full view: show all, included, and excluded counts
+                    print(f"\n   Available Tools: {len(all_tools)} total")
+                    print(f"   ├─ ✓ Included: {len(included_tools)}")
+                    print(f"   └─ ✗ Excluded: {len(excluded_tools)}")
+
+                # Show included tools with FULL descriptions and schemas
+                if included_tools:
+                    if options.apply_filters:
+                        print(f"\n   Tools ({len(included_tools)}):")
+                    else:
+                        print(f"\n   ✓ Included Tools ({len(included_tools)}):")
+
+                    for tool in included_tools:
+                        print(f"\n     • {tool.name}")
+                        if tool.description:
+                            # Show full description (no truncation)
+                            print(f"       Description: {tool.description}")
+                        if tool.input_schema:
+                            # Pretty print schema in readable format
+                            print("       Parameters:")
+                            pretty_schema = _format_schema_pretty(
+                                tool.input_schema, indent=0
+                            )
+                            if pretty_schema:
+                                # Indent the schema for better readability
+                                for line in pretty_schema.split("\n"):
+                                    print(f"         {line}")
+                            else:
+                                print("         (none)")
+
+                # Show excluded tools only if NOT applying filters
+                if excluded_tools and not options.apply_filters:
+                    print(f"\n   ✗ Excluded Tools ({len(excluded_tools)}):")
+                    for tool, reason in excluded_tools:
+                        print(f"     • {tool.name}{reason}")
+
+            print(f"\n{'-' * 80}\n")
+
+        # Summary
+        print(f"{'=' * 80}")
+        print(f"Summary: Found {len(mcp_tools_config)} MCP server(s)")
+        print(f"{'=' * 80}\n")
+
+        sys.exit(0)
+
+    except FileNotFoundError:
+        logger.error(f"Configuration file not found: {options.config}")
+        print(f"\n❌ Error: Configuration file not found: {options.config}")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"Failed to list MCP tools: {e}")
+        logger.debug(traceback.format_exc())
+        print(f"\n❌ Error: {e}")
+        sys.exit(1)
+
+
 def setup_logging(verbosity: int) -> None:
     levels: dict[int, str] = {
         0: "ERROR",
@@ -676,7 +1126,7 @@ def generate_bundle_from_template(config_path: Path, app_name: str) -> Path:
     4. Returns the path to the generated file
 
     The generated databricks.yaml is overwritten on each deployment and is not tracked in git.
-    Schema reference remains pointing to ./schemas/bundle_config_schema.json.
+    The template contains cloud-specific targets (azure, aws, gcp) with appropriate node types.
 
     Args:
         config_path: Path to the app config file
@@ -713,39 +1163,64 @@ def run_databricks_command(
     profile: Optional[str] = None,
     config: Optional[str] = None,
     target: Optional[str] = None,
+    cloud: Optional[str] = None,
     dry_run: bool = False,
+    deployment_target: Optional[str] = None,
 ) -> None:
-    """Execute a databricks CLI command with optional profile and target."""
+    """Execute a databricks CLI command with optional profile, target, and cloud.
+
+    Args:
+        command: The databricks CLI command to execute (e.g., ["bundle", "deploy"])
+        profile: Optional Databricks CLI profile name
+        config: Optional path to the configuration file
+        target: Optional bundle target name (if not provided, auto-generated from app name and cloud)
+        cloud: Optional cloud provider ('azure', 'aws', 'gcp'). Auto-detected if not specified.
+        dry_run: If True, print the command without executing
+        deployment_target: Optional agent deployment target ('model_serving' or 'apps').
+            Passed to the deploy notebook via bundle variable.
+    """
     config_path = Path(config) if config else None
 
     if config_path and not config_path.exists():
         logger.error(f"Configuration file {config_path} does not exist.")
         sys.exit(1)
 
-    # Load app config and generate bundle from template
+    # Load app config
     app_config: AppConfig = AppConfig.from_file(config_path) if config_path else None
     normalized_name: str = normalize_name(app_config.app.name) if app_config else None
 
+    # Auto-detect cloud provider if not specified (used for node_type selection)
+    if not cloud:
+        cloud = detect_cloud_provider(profile)
+        if cloud:
+            logger.info(f"Auto-detected cloud provider: {cloud}")
+        else:
+            logger.warning("Could not detect cloud provider. Defaulting to 'azure'.")
+            cloud = "azure"
+
     # Generate app-specific bundle from template (overwrites databricks.yaml temporarily)
     if config_path and app_config:
         generate_bundle_from_template(config_path, normalized_name)
 
-    # Use app name as target if not explicitly provided
-    # This ensures each app gets its own Terraform state in .databricks/bundle/<app-name>/
-    if not target and normalized_name:
-        target = normalized_name
-        logger.debug(f"Using app-specific target: {target}")
+    # Use app-specific cloud target: {app_name}-{cloud}
+    # This ensures each app has unique deployment identity while supporting cloud-specific settings
+    # Can be overridden with explicit --target
+    if not target:
+        target = f"{normalized_name}-{cloud}"
+        logger.info(f"Using app-specific cloud target: {target}")
 
-    # Build databricks command (no -c flag needed, uses databricks.yaml in current dir)
+    # Build databricks command
+    # --profile is a global flag, --target is a subcommand flag for 'bundle'
     cmd = ["databricks"]
     if profile:
         cmd.extend(["--profile", profile])
 
+    cmd.extend(command)
+
+    # --target must come after the bundle subcommand (it's a subcommand-specific flag)
     if target:
         cmd.extend(["--target", target])
 
-    cmd.extend(command)
-
     # Add config_path variable for notebooks
     if config_path and app_config:
         # Calculate relative path from notebooks directory to config file
@@ -760,6 +1235,26 @@ def run_databricks_command(
 
         cmd.append(f'--var="config_path={relative_config}"')
 
+    # Add deployment_target variable for notebooks (hybrid resolution)
+    # Priority: CLI arg > config file > default (model_serving)
+    resolved_deployment_target: str = "model_serving"
+    if deployment_target is not None:
+        resolved_deployment_target = deployment_target
+        logger.debug(
+            f"Using CLI-specified deployment target: {resolved_deployment_target}"
+        )
+    elif app_config and app_config.app and app_config.app.deployment_target:
+        # deployment_target is DeploymentTarget enum (str subclass) or string
+        # str() works for both since DeploymentTarget inherits from str
+        resolved_deployment_target = str(app_config.app.deployment_target)
+        logger.debug(
+            f"Using config file deployment target: {resolved_deployment_target}"
+        )
+    else:
+        logger.debug("Using default deployment target: model_serving")
+
+    cmd.append(f'--var="deployment_target={resolved_deployment_target}"')
+
     logger.debug(f"Executing command: {' '.join(cmd)}")
 
     if dry_run:
@@ -800,31 +1295,43 @@ def handle_bundle_command(options: Namespace) -> None:
     profile: Optional[str] = options.profile
     config: Optional[str] = options.config
     target: Optional[str] = options.target
+    cloud: Optional[str] = options.cloud
     dry_run: bool = options.dry_run
+    deployment_target: Optional[str] = options.deployment_target
 
     if options.deploy:
         logger.info("Deploying DAO AI asset bundle...")
         run_databricks_command(
-            ["bundle", "deploy"], profile, config, target, dry_run=dry_run
+            ["bundle", "deploy"],
+            profile=profile,
+            config=config,
+            target=target,
+            cloud=cloud,
+            dry_run=dry_run,
+            deployment_target=deployment_target,
         )
     if options.run:
         logger.info("Running DAO AI system with current configuration...")
         # Use static job resource key that matches databricks.yaml (resources.jobs.deploy_job)
         run_databricks_command(
             ["bundle", "run", "deploy_job"],
-            profile,
-            config,
-            target,
+            profile=profile,
+            config=config,
+            target=target,
+            cloud=cloud,
             dry_run=dry_run,
+            deployment_target=deployment_target,
         )
     if options.destroy:
         logger.info("Destroying DAO AI system with current configuration...")
         run_databricks_command(
             ["bundle", "destroy", "--auto-approve"],
-            profile,
-            config,
-            target,
+            profile=profile,
+            config=config,
+            target=target,
+            cloud=cloud,
             dry_run=dry_run,
+            deployment_target=deployment_target,
         )
     else:
         logger.warning("No action specified. Use --deploy, --run or --destroy flags.")
@@ -846,6 +1353,8 @@ def main() -> None:
             handle_deploy_command(options)
         case "chat":
             handle_chat_command(options)
+        case "list-mcp-tools":
+            handle_list_mcp_tools_command(options)
         case _:
             logger.error(f"Unknown command: {options.command}")
             sys.exit(1)