data-designer 0.4.0rc2__py3-none-any.whl → 0.5.0rc1__py3-none-any.whl

data_designer/cli/controllers/tool_controller.py

@@ -0,0 +1,236 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from data_designer.cli.forms.tool_builder import ToolFormBuilder
+from data_designer.cli.repositories.mcp_provider_repository import MCPProviderRepository
+from data_designer.cli.repositories.tool_repository import ToolRepository
+from data_designer.cli.services.mcp_provider_service import MCPProviderService
+from data_designer.cli.services.tool_service import ToolService
+from data_designer.cli.ui import (
+    confirm_action,
+    console,
+    display_config_preview,
+    print_error,
+    print_header,
+    print_info,
+    print_success,
+    select_with_arrows,
+)
+
+if TYPE_CHECKING:
+    from data_designer.config.mcp import ToolConfig
+
+
+class ToolController:
+    """Controller for tool configuration workflows."""
+
+    def __init__(self, config_dir: Path):
+        self.config_dir = config_dir
+        self.repository = ToolRepository(config_dir)
+        self.service = ToolService(self.repository)
+        self.mcp_provider_repository = MCPProviderRepository(config_dir)
+        self.mcp_provider_service = MCPProviderService(self.mcp_provider_repository)
+
+    def run(self) -> None:
+        """Main entry point for tool configuration."""
+        print_header("Configure Tool Configs")
+
+        # Check if MCP providers are configured
+        available_providers = self._get_available_providers()
+
+        if not available_providers:
+            print_error("No MCP providers available!")
+            print_info("Please run 'data-designer config mcp' first to configure MCP providers.")
+            return
+
+        print_info(f"Configuration directory: {self.config_dir}")
+        console.print()
+
+        # Check for existing configuration
+        tool_configs = self.service.list_all()
+
+        if tool_configs:
+            self._show_existing_config()
+            mode = self._select_mode()
+        else:
+            print_info("No tool configs configured yet")
+            console.print()
+            mode = "add"
+
+        if mode is None:
+            print_info("No changes made")
+            return
+
+        # Execute selected mode
+        mode_handlers = {
+            "add": self._handle_add,
+            "update": self._handle_update,
+            "delete": self._handle_delete,
+            "delete_all": self._handle_delete_all,
+        }
+
+        handler = mode_handlers.get(mode)
+        if handler:
+            handler(available_providers)
+
+    def _get_available_providers(self) -> list[str]:
+        """Get list of available MCP providers."""
+        return [p.name for p in self.mcp_provider_service.list_all()]
+
+    def _show_existing_config(self) -> None:
+        """Display current configuration."""
+        registry = self.repository.load()
+        if not registry:
+            return
+
+        print_info(f"Found {len(registry.tool_configs)} configured tool config(s)")
+        console.print()
+
+        # Display configuration
+        config_dict = registry.model_dump(mode="json", exclude_none=True)
+        display_config_preview(config_dict, "Current Configuration")
+        console.print()
+
+    def _select_mode(self) -> str | None:
+        """Prompt user to select operation mode."""
+        options = {
+            "add": "Add a new tool config",
+            "update": "Update an existing tool config",
+            "delete": "Delete a tool config",
+            "delete_all": "Delete all tool configs",
+            "exit": "Exit without changes",
+        }
+
+        result = select_with_arrows(
+            options,
+            "What would you like to do?",
+            default_key="add",
+            allow_back=False,
+        )
+
+        return None if result == "exit" or result is None else result
+
+    def _handle_add(self, available_providers: list[str]) -> None:
+        """Handle adding new tool configs."""
+        existing_aliases = {c.tool_alias for c in self.service.list_all()}
+
+        while True:
+            # Create builder with current existing aliases
+            builder = ToolFormBuilder(existing_aliases, available_providers)
+            tool_config = builder.run()
+
+            if tool_config is None:
+                break
+
+            # Attempt to add
+            try:
+                self.service.add(tool_config)
+                print_success(f"Tool config '{tool_config.tool_alias}' added successfully")
+                existing_aliases.add(tool_config.tool_alias)
+            except ValueError as e:
+                print_error(f"Failed to add tool config: {e}")
+                break
+
+            # Ask if they want to add more
+            if not self._confirm_add_another():
+                break
+
+    def _handle_update(self, available_providers: list[str]) -> None:
+        """Handle updating an existing tool config."""
+        tool_configs = self.service.list_all()
+        if not tool_configs:
+            print_error("No tool configs to update")
+            return
+
+        # Select tool config to update
+        selected_alias = self._select_tool_config(tool_configs, "Select tool config to update")
+        if selected_alias is None:
+            return
+
+        tool_config = self.service.get_by_alias(selected_alias)
+        if not tool_config:
+            print_error(f"Tool config '{selected_alias}' not found")
+            return
+
+        # Run builder with existing data
+        existing_aliases = {c.tool_alias for c in tool_configs if c.tool_alias != selected_alias}
+        builder = ToolFormBuilder(existing_aliases, available_providers)
+        initial_data = tool_config.model_dump(mode="json", exclude_none=True)
+        updated_config = builder.run(initial_data)
+
+        if updated_config:
+            try:
+                self.service.update(selected_alias, updated_config)
+                print_success(f"Tool config '{updated_config.tool_alias}' updated successfully")
+            except ValueError as e:
+                print_error(f"Failed to update tool config: {e}")
+
+    def _handle_delete(self, available_providers: list[str]) -> None:
+        """Handle deleting a tool config."""
+        tool_configs = self.service.list_all()
+        if not tool_configs:
+            print_error("No tool configs to delete")
+            return
+
+        # Select tool config to delete
+        selected_alias = self._select_tool_config(tool_configs, "Select tool config to delete")
+        if selected_alias is None:
+            return
+
+        # Confirm deletion
+        console.print()
+        if confirm_action(f"Delete tool config '{selected_alias}'?", default=False):
+            try:
+                self.service.delete(selected_alias)
+                print_success(f"Tool config '{selected_alias}' deleted successfully")
+            except ValueError as e:
+                print_error(f"Failed to delete tool config: {e}")
+
+    def _handle_delete_all(self, available_providers: list[str]) -> None:
+        """Handle deleting all tool configs."""
+        tool_configs = self.service.list_all()
+        if not tool_configs:
+            print_error("No tool configs to delete")
+            return
+
+        # List tool configs to be deleted
+        console.print()
+        config_count = len(tool_configs)
+        config_aliases = ", ".join([f"'{c.tool_alias}'" for c in tool_configs])
+
+        if confirm_action(
+            f"Delete ALL ({config_count}) tool config(s): {config_aliases}?\n   This action cannot be undone.",
+            default=False,
+        ):
+            try:
+                self.repository.delete()
+                print_success(f"All ({config_count}) tool config(s) deleted successfully")
+            except Exception as e:
+                print_error(f"Failed to delete all tool configs: {e}")
+
+    def _select_tool_config(
+        self, tool_configs: list[ToolConfig], prompt: str, default: str | None = None
+    ) -> str | None:
+        """Helper to select a tool config from list."""
+        options = {c.tool_alias: f"{c.tool_alias} (providers: {', '.join(c.providers)})" for c in tool_configs}
+        return select_with_arrows(
+            options,
+            prompt,
+            default_key=default or tool_configs[0].tool_alias,
+            allow_back=False,
+        )
+
+    def _confirm_add_another(self) -> bool:
+        """Ask if user wants to add another tool config."""
+        result = select_with_arrows(
+            {"yes": "Add another tool config", "no": "Finish"},
+            "Add another tool config?",
+            default_key="no",
+            allow_back=False,
+        )
+        return result == "yes"

data_designer/cli/forms/mcp_provider_builder.py

@@ -0,0 +1,219 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any
+
+from data_designer.cli.forms.field import TextField
+from data_designer.cli.forms.form import Form
+from data_designer.cli.ui import (
+    confirm_action,
+    console,
+    print_error,
+    print_header,
+    select_with_arrows,
+)
+from data_designer.cli.utils import validate_url
+from data_designer.config.mcp import LocalStdioMCPProvider, MCPProvider, MCPProviderT
+
+
+class MCPProviderFormBuilder:
+    """Builds interactive forms for MCP provider configuration.
+
+    Supports both MCPProvider (remote SSE) and LocalStdioMCPProvider (subprocess).
+    """
+
+    def __init__(self, existing_names: set[str] | None = None):
+        self.title = "MCP Provider Configuration"
+        self.existing_names = existing_names or set()
+
+    def run(self, initial_data: dict[str, Any] | None = None) -> MCPProviderT | None:
+        """Run the interactive MCP provider configuration and return configured object."""
+        print_header(self.title)
+
+        while True:
+            # Determine provider type
+            if initial_data and initial_data.get("provider_type"):
+                provider_type = initial_data["provider_type"]
+            else:
+                provider_type = self._select_provider_type()
+                if provider_type is None:
+                    return None
+
+            # Run appropriate form based on provider type
+            if provider_type == "sse":
+                result = self._run_sse_form(initial_data)
+            else:  # stdio
+                result = self._run_stdio_form(initial_data)
+
+            if result is not None:
+                return result
+
+            # If form was cancelled, ask if they want to try again
+            if not confirm_action("Try a different provider type?", default=False):
+                return None
+            initial_data = None  # Reset for new selection
+
+    def _select_provider_type(self) -> str | None:
+        """Prompt user to select provider type."""
+        options = {
+            "sse": "Remote SSE server (connect to existing server)",
+            "stdio": "Local stdio subprocess (launch server as subprocess)",
+        }
+
+        console.print()
+        return select_with_arrows(
+            options,
+            "What type of MCP provider?",
+            default_key="sse",
+            allow_back=True,
+        )
+
+    def _run_sse_form(self, initial_data: dict[str, Any] | None = None) -> MCPProvider | None:
+        """Run form for remote SSE provider."""
+        fields = [
+            TextField(
+                "name",
+                "MCP provider name",
+                default=initial_data.get("name") if initial_data else None,
+                required=True,
+                validator=self._validate_name,
+            ),
+            TextField(
+                "endpoint",
+                "SSE endpoint URL",
+                default=initial_data.get("endpoint") if initial_data else None,
+                required=True,
+                validator=self._validate_endpoint,
+            ),
+            TextField(
+                "api_key",
+                "API key or environment variable name (optional)",
+                default=initial_data.get("api_key") if initial_data else None,
+                required=False,
+            ),
+        ]
+
+        form = Form("Remote SSE Provider", fields)
+        if initial_data:
+            form.set_values(initial_data)
+
+        result = form.prompt_all(allow_back=True)
+        if result is None:
+            return None
+
+        try:
+            return MCPProvider(
+                name=result["name"],
+                endpoint=result["endpoint"],
+                api_key=result.get("api_key") or None,
+            )
+        except Exception as e:
+            print_error(f"Configuration error: {e}")
+            return None
+
+    def _run_stdio_form(self, initial_data: dict[str, Any] | None = None) -> LocalStdioMCPProvider | None:
+        """Run form for local stdio provider."""
+        # Convert args list to comma-separated string for display
+        args_default = None
+        if initial_data and initial_data.get("args"):
+            args_default = ",".join(initial_data["args"])
+
+        # Convert env dict to KEY=VALUE,KEY2=VALUE2 format for display
+        env_default = None
+        if initial_data and initial_data.get("env"):
+            env_default = ",".join(f"{k}={v}" for k, v in initial_data["env"].items())
+
+        fields = [
+            TextField(
+                "name",
+                "MCP provider name",
+                default=initial_data.get("name") if initial_data else None,
+                required=True,
+                validator=self._validate_name,
+            ),
+            TextField(
+                "command",
+                "Command to run (e.g., python, node, npx)",
+                default=initial_data.get("command") if initial_data else None,
+                required=True,
+                validator=self._validate_command,
+            ),
+            TextField(
+                "args",
+                "Arguments (comma-separated, e.g., -m,my_server,--port,8080)",
+                default=args_default,
+                required=False,
+            ),
+            TextField(
+                "env",
+                "Environment variables (KEY=VALUE, comma-separated)",
+                default=env_default,
+                required=False,
+            ),
+        ]
+
+        form = Form("Local Stdio Provider", fields)
+        if initial_data:
+            form.set_values(
+                {
+                    "name": initial_data.get("name"),
+                    "command": initial_data.get("command"),
+                    "args": args_default,
+                    "env": env_default,
+                }
+            )
+
+        result = form.prompt_all(allow_back=True)
+        if result is None:
+            return None
+
+        try:
+            # Parse args from comma-separated string
+            args: list[str] = []
+            if result.get("args"):
+                args = [a.strip() for a in result["args"].split(",") if a.strip()]
+
+            # Parse env from KEY=VALUE format
+            env: dict[str, str] = {}
+            if result.get("env"):
+                for pair in result["env"].split(","):
+                    pair = pair.strip()
+                    if "=" in pair:
+                        key, value = pair.split("=", 1)
+                        env[key.strip()] = value.strip()
+
+            return LocalStdioMCPProvider(
+                name=result["name"],
+                command=result["command"],
+                args=args,
+                env=env,
+            )
+        except Exception as e:
+            print_error(f"Configuration error: {e}")
+            return None
+
+    def _validate_name(self, name: str) -> tuple[bool, str | None]:
+        """Validate MCP provider name."""
+        if not name:
+            return False, "MCP provider name is required"
+        if name in self.existing_names:
+            return False, f"MCP provider '{name}' already exists"
+        return True, None
+
+    def _validate_endpoint(self, endpoint: str) -> tuple[bool, str | None]:
+        """Validate endpoint URL."""
+        if not endpoint:
+            return False, "Endpoint URL is required"
+        if not validate_url(endpoint):
+            return False, "Invalid URL format (must start with http:// or https://)"
+        return True, None
+
+    def _validate_command(self, command: str) -> tuple[bool, str | None]:
+        """Validate command."""
+        if not command:
+            return False, "Command is required"
+        if not command.strip():
+            return False, "Command cannot be empty"
+        return True, None

data_designer/cli/forms/tool_builder.py

@@ -0,0 +1,204 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any
+
+from data_designer.cli.forms.field import TextField
+from data_designer.cli.forms.form import Form
+from data_designer.cli.ui import (
+    confirm_action,
+    console,
+    print_error,
+    print_header,
+    print_info,
+    select_multiple_with_arrows,
+)
+from data_designer.config.mcp import ToolConfig
+
+
+class ToolFormBuilder:
+    """Builds interactive forms for tool configuration.
+
+    This builder uses a custom flow with multi-select for providers
+    rather than the standard FormBuilder pattern.
+    """
+
+    def __init__(
+        self,
+        existing_aliases: set[str] | None = None,
+        available_providers: list[str] | None = None,
+    ):
+        self.title = "Tool Configuration"
+        self.existing_aliases = existing_aliases or set()
+        self.available_providers = available_providers or []
+
+    def run(self, initial_data: dict[str, Any] | None = None) -> ToolConfig | None:
+        """Run the interactive tool configuration and return configured object."""
+        print_header(self.title)
+
+        while True:
+            # Step 1: Get tool alias
+            form = self._create_alias_form(initial_data)
+            if initial_data:
+                form.set_values(initial_data)
+
+            result = form.prompt_all(allow_back=True)
+            if result is None:
+                if confirm_action("Cancel configuration?", default=False):
+                    return None
+                continue
+
+            tool_alias = result["tool_alias"]
+
+            # Step 2: Select providers (multi-select with checkboxes)
+            if not self.available_providers:
+                print_error("No MCP providers available. Please configure MCP providers first.")
+                print_info("Run 'data-designer config mcp' to configure MCP providers.")
+                return None
+
+            console.print()
+            print_info("Select one or more MCP providers for this tool configuration:")
+            console.print()
+
+            default_providers = initial_data.get("providers") if initial_data else None
+            provider_options = {p: p for p in self.available_providers}
+            selected_providers = select_multiple_with_arrows(
+                provider_options,
+                "Select MCP providers (Space to toggle, Enter to confirm):",
+                default_keys=default_providers,
+                allow_empty=False,
+            )
+
+            if selected_providers is None:
+                if confirm_action("Cancel configuration?", default=False):
+                    return None
+                continue
+
+            if not selected_providers:
+                print_error("At least one provider must be selected")
+                continue
+
+            # Step 3: Get optional settings
+            optional_form = self._create_optional_form(initial_data)
+            if initial_data:
+                optional_form.set_values(initial_data)
+
+            optional_result = optional_form.prompt_all(allow_back=True)
+            if optional_result is None:
+                continue  # Go back to start
+
+            try:
+                config = self._build_config(tool_alias, selected_providers, optional_result)
+                return config
+            except Exception as e:
+                print_error(f"Configuration error: {e}")
+                if not confirm_action("Try again?", default=True):
+                    return None
+
+    def _create_alias_form(self, initial_data: dict[str, Any] | None = None) -> Form:
+        """Create the form for tool alias."""
+        fields = [
+            TextField(
+                "tool_alias",
+                "Tool alias (used to reference this config in columns)",
+                default=initial_data.get("tool_alias") if initial_data else None,
+                required=True,
+                validator=self._validate_alias,
+            ),
+        ]
+        return Form("Tool Alias", fields)
+
+    def _create_optional_form(self, initial_data: dict[str, Any] | None = None) -> Form:
+        """Create the form for optional tool settings."""
+        # Convert allow_tools list to comma-separated string for display
+        allow_tools_default = None
+        if initial_data and initial_data.get("allow_tools"):
+            allow_tools_default = ", ".join(initial_data["allow_tools"])
+
+        fields = [
+            TextField(
+                "allow_tools",
+                "Allowed tools (comma-separated, leave empty for all)",
+                default=allow_tools_default,
+                required=False,
+            ),
+            TextField(
+                "max_tool_call_turns",
+                "Max tool-calling turns (a turn may execute multiple parallel tools)",
+                default=str(initial_data.get("max_tool_call_turns", 5)) if initial_data else "5",
+                required=False,
+                validator=self._validate_max_tool_call_turns,
+            ),
+            TextField(
+                "timeout_sec",
+                "Timeout in seconds per tool call (leave empty for no timeout)",
+                default=str(initial_data.get("timeout_sec", "")) if initial_data else None,
+                required=False,
+                validator=self._validate_timeout,
+            ),
+        ]
+        return Form("Optional Settings", fields)
+
+    def _validate_alias(self, alias: str) -> tuple[bool, str | None]:
+        """Validate tool alias."""
+        if not alias:
+            return False, "Tool alias is required"
+        if alias in self.existing_aliases:
+            return False, f"Tool alias '{alias}' already exists"
+        return True, None
+
+    def _validate_max_tool_call_turns(self, value: str) -> tuple[bool, str | None]:
+        """Validate max_tool_call_turns."""
+        if not value:
+            return True, None  # Will use default
+        try:
+            int_value = int(value)
+            if int_value < 1:
+                return False, "Must be at least 1"
+            return True, None
+        except ValueError:
+            return False, "Must be a positive integer"
+
+    def _validate_timeout(self, value: str) -> tuple[bool, str | None]:
+        """Validate timeout_sec."""
+        if not value:
+            return True, None  # No timeout is valid
+        try:
+            float_value = float(value)
+            if float_value <= 0:
+                return False, "Must be greater than 0"
+            return True, None
+        except ValueError:
+            return False, "Must be a positive number"
+
+    def _build_config(
+        self,
+        tool_alias: str,
+        providers: list[str],
+        optional_data: dict[str, Any],
+    ) -> ToolConfig:
+        """Build ToolConfig from collected data."""
+        # Parse allow_tools from comma-separated string
+        allow_tools = None
+        if optional_data.get("allow_tools"):
+            allow_tools = [t.strip() for t in optional_data["allow_tools"].split(",") if t.strip()]
+
+        # Parse max_tool_call_turns
+        max_tool_call_turns = 5
+        if optional_data.get("max_tool_call_turns"):
+            max_tool_call_turns = int(optional_data["max_tool_call_turns"])
+
+        # Parse timeout_sec
+        timeout_sec = None
+        if optional_data.get("timeout_sec"):
+            timeout_sec = float(optional_data["timeout_sec"])
+
+        return ToolConfig(
+            tool_alias=tool_alias,
+            providers=providers,
+            allow_tools=allow_tools if allow_tools else None,
+            max_tool_call_turns=max_tool_call_turns,
+            timeout_sec=timeout_sec,
+        )

data_designer/cli/main.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 import typer
 
-from data_designer.cli.commands import download, models, providers, reset
+from data_designer.cli.commands import download, mcp, models, providers, reset, tools
 from data_designer.cli.commands import list as list_cmd
 from data_designer.config.default_model_settings import resolve_seed_default_model_settings
 from data_designer.config.utils.misc import can_run_data_designer_locally
@@ -31,6 +31,8 @@ config_app = typer.Typer(
 )
 config_app.command(name="providers", help="Configure model providers interactively")(providers.providers_command)
 config_app.command(name="models", help="Configure models interactively")(models.models_command)
+config_app.command(name="mcp", help="Configure MCP providers interactively")(mcp.mcp_command)
+config_app.command(name="tools", help="Configure tool configs interactively")(tools.tools_command)
 config_app.command(name="list", help="List current configurations")(list_cmd.list_command)
 config_app.command(name="reset", help="Reset configuration files")(reset.reset_command)