Dialog mode cli (#1540)

Author: aymeric-roucher

README.md

@@ -178,9 +178,20 @@ You can run agents from CLI using two commands: `smolagent` and `webagent`.
 `smolagent` is a generalist command to run a multi-step `CodeAgent` that can be equipped with various tools.
 
 ```bash
+# Run with direct prompt and options
 smolagent "Plan a trip to Tokyo, Kyoto and Osaka between Mar 28 and Apr 7."  --model-type "InferenceClientModel" --model-id "Qwen/Qwen3-Next-80B-A3B-Thinking" --imports pandas numpy --tools web_search
+
+# Run in interactive mode (launches setup wizard when no prompt provided)
+smolagent
 ```
 
+Interactive mode guides you through:
+- Agent type selection (CodeAgent vs ToolCallingAgent)  
+- Tool selection from available toolbox
+- Model configuration (type, ID, API settings)
+- Advanced options like additional imports
+- Task prompt input
+
 Meanwhile `webagent` is a specific web-browsing agent using [helium](https://github.com/mherrmann/helium) (read more [here](https://github.com/huggingface/smolagents/blob/main/src/smolagents/vision_web_browser.py)).
 
 For instance:

docs/source/en/guided_tour.md

@@ -104,6 +104,18 @@ agent = ToolCallingAgent(tools=[WebSearchTool()], model=model)
 agent.run("Could you get me the title of the page at url 'https://huggingface.co/blog'?")
 ```
 
+## Using the CLI
+
+You can quickly get started with smolagents using the command line interface:
+
+```bash
+# Run with direct prompt and options
+smolagent "Plan a trip to Tokyo, Kyoto and Osaka between Mar 28 and Apr 7."  --model-type "InferenceClientModel" --model-id "Qwen/Qwen2.5-Coder-32B-Instruct" --imports "pandas numpy" --tools "web_search"
+
+# Run in interactive mode: launches when no prompt is provided, will guide you through argument selection
+smolagent
+```
+
 ## Building your agent
 
 To initialize a minimal agent, you need at least these two arguments:

src/smolagents/cli.py

@@ -18,11 +18,27 @@
 import os
 
 from dotenv import load_dotenv
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.rule import Rule
+from rich.table import Table
 
-from smolagents import CodeAgent, InferenceClientModel, LiteLLMModel, Model, OpenAIModel, Tool, TransformersModel
+from smolagents import (
+    CodeAgent,
+    InferenceClientModel,
+    LiteLLMModel,
+    Model,
+    OpenAIModel,
+    Tool,
+    ToolCallingAgent,
+    TransformersModel,
+)
 from smolagents.default_tools import TOOL_MAPPING
 
 
+console = Console()
+
 leopard_prompt = "How many seconds would it take for a leopard at full speed to run through Pont des Arts?"
 
 
@@ -31,16 +47,22 @@ def parse_arguments():
     parser.add_argument(
         "prompt",
         type=str,
-        nargs="?",  # Makes it optional
-        default=leopard_prompt,
-        help="The prompt to run with the agent",
+        nargs="?",
+        default=None,
+        help="The prompt to run with the agent. If no prompt is provided, interactive mode will be launched to guide user through agent setup",
     )
     parser.add_argument(
         "--model-type",
         type=str,
         default="InferenceClientModel",
         help="The model type to use (e.g., InferenceClientModel, OpenAIModel, LiteLLMModel, TransformersModel)",
     )
+    parser.add_argument(
+        "--action-type",
+        type=str,
+        default="code",
+        help="The action type to use (e.g., code, tool_calling)",
+    )
     parser.add_argument(
         "--model-id",
         type=str,
@@ -85,6 +107,84 @@ def parse_arguments():
     return parser.parse_args()
 
 
+def interactive_mode():
+    """Run the CLI in interactive mode"""
+    console.print(
+        Panel.fit(
+            "[bold magenta]🤖 SmolaGents CLI[/]\n[dim]Intelligent agents at your service[/]", border_style="magenta"
+        )
+    )
+
+    console.print("\n[bold yellow]Welcome to smolagents![/] Let's set up your agent step by step.\n")
+
+    # Get user input step by step
+    console.print(Rule("[bold yellow]⚙️  Configuration", style="bold yellow"))
+
+    # Get agent action type
+    action_type = Prompt.ask(
+        "[bold white]What action type would you like to use? 'code' or 'tool_calling'?[/]",
+        default="code",
+        choices=["code", "tool_calling"],
+    )
+
+    # Show available tools
+    tools_table = Table(title="[bold yellow]🛠️  Available Tools", show_header=True, header_style="bold yellow")
+    tools_table.add_column("Tool Name", style="bold yellow")
+    tools_table.add_column("Description", style="white")
+
+    for tool_name, tool_class in TOOL_MAPPING.items():
+        # Get description from the tool class if available
+        try:
+            tool_instance = tool_class()
+            description = getattr(tool_instance, "description", "No description available")
+        except Exception:
+            description = "Built-in tool"
+        tools_table.add_row(tool_name, description)
+
+    console.print(tools_table)
+    console.print(
+        "\n[dim]You can also use HuggingFace Spaces by providing the full path (e.g., 'username/spacename')[/]"
+    )
+
+    console.print("[dim]Enter tool names separated by spaces (e.g., 'web_search python_interpreter')[/]")
+    tools_input = Prompt.ask("[bold white]Select tools for your agent[/]", default="web_search")
+    tools = tools_input.split()
+
+    # Get model configuration
+    console.print("\n[bold yellow]Model Configuration:[/]")
+    model_type = Prompt.ask(
+        "[bold]Model type[/]",
+        default="InferenceClientModel",
+        choices=["InferenceClientModel", "OpenAIServerModel", "LiteLLMModel", "TransformersModel"],
+    )
+
+    model_id = Prompt.ask("[bold white]Model ID[/]", default="Qwen/Qwen2.5-Coder-32B-Instruct")
+
+    # Optional configurations
+    provider = None
+    api_base = None
+    api_key = None
+    imports = []
+    action_type = "code"
+
+    if Confirm.ask("\n[bold white]Configure advanced options?[/]", default=False):
+        if model_type in ["InferenceClientModel", "OpenAIServerModel", "LiteLLMModel"]:
+            provider = Prompt.ask("[bold white]Provider[/]", default="")
+            api_base = Prompt.ask("[bold white]API Base URL[/]", default="")
+            api_key = Prompt.ask("[bold white]API Key[/]", default="", password=True)
+
+        imports_input = Prompt.ask("[bold white]Additional imports (space-separated)[/]", default="")
+        if imports_input:
+            imports = imports_input.split()
+
+    # Get prompt
+    prompt = Prompt.ask(
+        "[bold white]Now the final step; what task would you like the agent to perform?[/]", default=leopard_prompt
+    )
+
+    return prompt, tools, model_type, model_id, provider, api_base, api_key, imports, action_type
+
+
 def load_model(
     model_type: str,
     model_id: str,
@@ -125,38 +225,68 @@ def run_smolagent(
     api_key: str | None = None,
     imports: list[str] | None = None,
     provider: str | None = None,
+    action_type: str = "code",
 ) -> None:
     load_dotenv()
 
     model = load_model(model_type, model_id, api_base=api_base, api_key=api_key, provider=provider)
 
     available_tools = []
+
     for tool_name in tools:
         if "/" in tool_name:
-            available_tools.append(Tool.from_space(tool_name))
+            available_tools.append(
+                Tool.from_space(tool_name, name=tool_name.split("/")[-1], description=f"Tool from space: {tool_name}")
+            )
         else:
             if tool_name in TOOL_MAPPING:
                 available_tools.append(TOOL_MAPPING[tool_name]())
             else:
                 raise ValueError(f"Tool {tool_name} is not recognized either as a default tool or a Space.")
 
-    print(f"Running agent with these tools: {tools}")
-    agent = CodeAgent(tools=available_tools, model=model, additional_authorized_imports=imports)
+    if action_type == "code":
+        agent = CodeAgent(
+            tools=available_tools,
+            model=model,
+            additional_authorized_imports=imports,
+            stream_outputs=True,
+        )
+    elif action_type == "tool_calling":
+        agent = ToolCallingAgent(tools=available_tools, model=model, stream_outputs=True)
+    else:
+        raise ValueError(f"Unsupported action type: {action_type}")
 
     agent.run(prompt)
 
 
 def main() -> None:
     args = parse_arguments()
+
+    # Check if we should run in interactive mode
+    # Interactive mode is triggered when no prompt is provided
+    if args.prompt is None:
+        prompt, tools, model_type, model_id, provider, api_base, api_key, imports, action_type = interactive_mode()
+    else:
+        prompt = args.prompt
+        tools = args.tools
+        model_type = args.model_type
+        model_id = args.model_id
+        provider = args.provider
+        api_base = args.api_base
+        api_key = args.api_key
+        imports = args.imports
+        action_type = args.action_type
+
     run_smolagent(
-        args.prompt,
-        args.tools,
-        args.model_type,
-        args.model_id,
-        provider=args.provider,
-        api_base=args.api_base,
-        api_key=args.api_key,
-        imports=args.imports,
+        prompt,
+        tools,
+        model_type,
+        model_id,
+        provider=provider,
+        api_base=api_base,
+        api_key=api_key,
+        imports=imports,
+        action_type=action_type,
     )
 
 

src/smolagents/monitoring.py

@@ -190,7 +190,7 @@ def log_code(self, title: str, content: str, level: int = LogLevel.INFO) -> None
     def log_rule(self, title: str, level: int = LogLevel.INFO) -> None:
         self.log(
             Rule(
-                "[bold]" + title,
+                "[bold white]" + title,
                 characters="━",
                 style=YELLOW_HEX,
             ),

src/smolagents/tools.py

@@ -600,7 +600,7 @@ def from_code(cls, tool_code: str, **kwargs):
     def from_space(
         space_id: str,
         name: str,
-        description: str,
+        description: str = "",
         api_name: str | None = None,
         token: str | None = None,
     ):
@@ -649,7 +649,7 @@ def __init__(
                 self,
                 space_id: str,
                 name: str,
-                description: str,
+                description: str = "",
                 api_name: str | None = None,
                 token: str | None = None,
             ):

tests/test_cli.py

@@ -77,13 +77,11 @@ def test_cli_main(capsys):
         "tools": [],
         "model": "mock_model",
         "additional_authorized_imports": None,
+        "stream_outputs": True,
     }
     # agent.run
     assert len(mock_code_agent.return_value.run.call_args_list) == 1
     assert mock_code_agent.return_value.run.call_args.args == ("test_prompt",)
-    # print
-    captured = capsys.readouterr()
-    assert "Running agent with these tools: []" in captured.out
 
 
 def test_vision_web_browser_main():