fast-agent-mcp 0.2.36__py3-none-any.whl → 0.2.38__py3-none-any.whl

mcp_agent/resources/examples/mcp/elicitations/elicitation_game_server.py

@@ -0,0 +1,164 @@
+"""
+MCP Server for Game Character Creation
+
+This server provides a fun game character creation form
+that can be used with custom handlers.
+"""
+
+import logging
+import random
+import sys
+
+from mcp import ReadResourceResult
+from mcp.server.elicitation import (
+    AcceptedElicitation,
+    CancelledElicitation,
+    DeclinedElicitation,
+)
+from mcp.server.fastmcp import FastMCP
+from mcp.types import TextResourceContents
+from pydantic import AnyUrl, BaseModel, Field
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    stream=sys.stderr,
+)
+logger = logging.getLogger("elicitation_game_server")
+
+# Create MCP server
+mcp = FastMCP("Game Character Creation Server", log_level="INFO")
+
+
+@mcp.resource(uri="elicitation://game-character")
+async def game_character() -> ReadResourceResult:
+    """Fun game character creation form for the whimsical example."""
+
+    class GameCharacter(BaseModel):
+        character_name: str = Field(description="Name your character", min_length=2, max_length=30)
+        character_class: str = Field(
+            description="Choose your class",
+            json_schema_extra={
+                "enum": ["warrior", "mage", "rogue", "ranger", "paladin", "bard"],
+                "enumNames": [
+                    "⚔️ Warrior",
+                    "🔮 Mage",
+                    "🗡️ Rogue",
+                    "🏹 Ranger",
+                    "🛡️ Paladin",
+                    "🎵 Bard",
+                ],
+            },
+        )
+        strength: int = Field(description="Strength (3-18)", ge=3, le=18, default=10)
+        intelligence: int = Field(description="Intelligence (3-18)", ge=3, le=18, default=10)
+        dexterity: int = Field(description="Dexterity (3-18)", ge=3, le=18, default=10)
+        charisma: int = Field(description="Charisma (3-18)", ge=3, le=18, default=10)
+        lucky_dice: bool = Field(False, description="Roll for a lucky bonus?")
+
+    result = await mcp.get_context().elicit("🎮 Create Your Game Character!", schema=GameCharacter)
+
+    match result:
+        case AcceptedElicitation(data=data):
+            lines = [
+                f"🎭 Character Created: {data.character_name}",
+                f"Class: {data.character_class.title()}",
+                f"Stats: STR:{data.strength} INT:{data.intelligence} DEX:{data.dexterity} CHA:{data.charisma}",
+            ]
+
+            if data.lucky_dice:
+                dice_roll = random.randint(1, 20)
+                if dice_roll >= 15:
+                    bonus = random.choice(
+                        [
+                            "🎁 Lucky! +2 to all stats!",
+                            "🌟 Critical! Found a magic item!",
+                            "💰 Jackpot! +100 gold!",
+                        ]
+                    )
+                    lines.append(f"🎲 Dice Roll: {dice_roll} - {bonus}")
+                else:
+                    lines.append(f"🎲 Dice Roll: {dice_roll} - No bonus this time!")
+
+            total_stats = data.strength + data.intelligence + data.dexterity + data.charisma
+            if total_stats > 50:
+                lines.append("💪 Powerful character build!")
+            elif total_stats < 30:
+                lines.append("🎯 Challenging build - good luck!")
+
+            response = "\n".join(lines)
+        case DeclinedElicitation():
+            response = "Character creation declined - returning to menu"
+        case CancelledElicitation():
+            response = "Character creation cancelled"
+
+    return ReadResourceResult(
+        contents=[
+            TextResourceContents(
+                mimeType="text/plain", uri=AnyUrl("elicitation://game-character"), text=response
+            )
+        ]
+    )
+
+
+@mcp.tool()
+async def roll_new_character(campaign_name: str = "Adventure") -> str:
+    """
+    Roll a new character for your campaign.
+
+    Args:
+        campaign_name: The name of the campaign
+
+    Returns:
+        Character details or status message
+    """
+
+    class GameCharacter(BaseModel):
+        character_name: str = Field(description="Name your character", min_length=2, max_length=30)
+        character_class: str = Field(
+            description="Choose your class",
+            json_schema_extra={
+                "enum": ["warrior", "mage", "rogue", "ranger", "paladin", "bard"],
+                "enumNames": [
+                    "⚔️ Warrior",
+                    "🔮 Mage",
+                    "🗡️ Rogue",
+                    "🏹 Ranger",
+                    "🛡️ Paladin",
+                    "🎵 Bard",
+                ],
+            },
+        )
+        strength: int = Field(description="Strength (3-18)", ge=3, le=18, default=10)
+        intelligence: int = Field(description="Intelligence (3-18)", ge=3, le=18, default=10)
+        dexterity: int = Field(description="Dexterity (3-18)", ge=3, le=18, default=10)
+        charisma: int = Field(description="Charisma (3-18)", ge=3, le=18, default=10)
+        lucky_dice: bool = Field(False, description="Roll for a lucky bonus?")
+
+    result = await mcp.get_context().elicit(
+        f"🎮 Create Character for {campaign_name}!", schema=GameCharacter
+    )
+
+    match result:
+        case AcceptedElicitation(data=data):
+            response = f"🎭 {data.character_name} the {data.character_class.title()} joins {campaign_name}!\n"
+            response += f"Stats: STR:{data.strength} INT:{data.intelligence} DEX:{data.dexterity} CHA:{data.charisma}"
+
+            if data.lucky_dice:
+                dice_roll = random.randint(1, 20)
+                if dice_roll >= 15:
+                    response += f"\n🎲 Lucky roll ({dice_roll})! Starting with bonus equipment!"
+                else:
+                    response += f"\n🎲 Rolled {dice_roll} - Standard starting gear."
+
+            return response
+        case DeclinedElicitation():
+            return f"Character creation for {campaign_name} was declined"
+        case CancelledElicitation():
+            return f"Character creation for {campaign_name} was cancelled"
+
+
+if __name__ == "__main__":
+    logger.info("Starting game character creation server...")
+    mcp.run()

mcp_agent/resources/examples/mcp/elicitations/fastagent.config.yaml

@@ -0,0 +1,35 @@
+# Model string takes format:
+#   <provider>.<model_string>.<reasoning_effort?> (e.g. anthropic.claude-3-5-sonnet-20241022 or openai.o3-mini.low)
+#
+# Can be overriden with a command line switch --model=<model>, or within the Agent decorator.
+# Check here for current details: https://fast-agent.ai/models/
+default_model: "passthrough"
+
+# Logging and Console Configuration
+logger:
+  level: "error"
+  type: "console"
+
+# MCP Server Configuration
+mcp:
+  servers:
+    # Forms demo server - interactive form examples
+    elicitation_forms_server:
+      command: "uv"
+      args: ["run", "elicitation_forms_server.py"]
+      elicitation:
+        mode: "forms" # Shows forms to users (default)
+
+    # Account creation server - for CALL_TOOL demos
+    elicitation_account_server:
+      command: "uv"
+      args: ["run", "elicitation_account_server.py"]
+      elicitation:
+        mode: "forms"
+
+    # Game character server - for custom handler demos
+    elicitation_game_server:
+      command: "uv"
+      args: ["run", "elicitation_game_server.py"]
+      elicitation:
+        mode: "forms"

mcp_agent/resources/examples/mcp/elicitations/fastagent.secrets.yaml.example

@@ -0,0 +1,17 @@
+# Secrets configuration for elicitation examples
+#
+# Rename this file to fastagent.secrets.yaml and add your API keys
+# to use the account_creation.py example with real LLMs
+
+# OpenAI
+openai_api_key: "sk-..."
+
+# Anthropic
+anthropic_api_key: "sk-ant-..."
+
+# Google (Gemini)
+google_api_key: "..."
+
+# Other providers - see documentation for full list
+# groq_api_key: "..."
+# mistral_api_key: "..."

mcp_agent/resources/examples/mcp/elicitations/forms_demo.py

@@ -0,0 +1,111 @@
+"""
+Quick Start: Elicitation Forms Demo
+
+This example demonstrates the elicitation forms feature of fast-agent.
+
+When Read Resource requests are sent to the MCP Server, it generates an Elicitation
+which creates a form for the user to fill out.
+The results are returned to the demo program which prints out the results in a rich format.
+"""
+
+import asyncio
+
+from rich.console import Console
+from rich.panel import Panel
+
+from mcp_agent.core.fastagent import FastAgent
+from mcp_agent.mcp.helpers.content_helpers import get_resource_text
+
+fast = FastAgent("Elicitation Forms Demo", quiet=True)
+console = Console()
+
+
+@fast.agent(
+    "forms-demo",
+    servers=[
+        "elicitation_forms_server",
+    ],
+)
+async def main():
+    """Run the improved forms demo showcasing all elicitation features."""
+    async with fast.run() as agent:
+        console.print("\n[bold cyan]Welcome to the Elicitation Forms Demo![/bold cyan]\n")
+        console.print("This demo shows how to collect structured data using MCP Elicitations.")
+        console.print("We'll present several forms and display the results collected for each.\n")
+
+        # Example 1: Event Registration
+        console.print("[bold yellow]Example 1: Event Registration Form[/bold yellow]")
+        console.print(
+            "[dim]Demonstrates: string validation, email format, URL format, date format[/dim]"
+        )
+        result = await agent.get_resource("elicitation://event-registration")
+
+        if result_text := get_resource_text(result):
+            panel = Panel(
+                result_text,
+                title="🎫 Registration Confirmation",
+                border_style="green",
+                expand=False,
+            )
+            console.print(panel)
+        else:
+            console.print("[red]No registration data received[/red]")
+
+        console.print("\n" + "─" * 50 + "\n")
+
+        # Example 2: Product Review
+        console.print("[bold yellow]Example 2: Product Review Form[/bold yellow]")
+        console.print(
+            "[dim]Demonstrates: number validation (range), radio selection, multiline text[/dim]"
+        )
+        result = await agent.get_resource("elicitation://product-review")
+
+        if result_text := get_resource_text(result):
+            review_panel = Panel(
+                result_text, title="🛍️ Product Review", border_style="cyan", expand=False
+            )
+            console.print(review_panel)
+
+        console.print("\n" + "─" * 50 + "\n")
+
+        # Example 3: Account Settings
+        console.print("[bold yellow]Example 3: Account Settings Form[/bold yellow]")
+        console.print(
+            "[dim]Demonstrates: boolean selections, radio selection, number validation[/dim]"
+        )
+        result = await agent.get_resource("elicitation://account-settings")
+
+        if result_text := get_resource_text(result):
+            settings_panel = Panel(
+                result_text, title="⚙️ Account Settings", border_style="blue", expand=False
+            )
+            console.print(settings_panel)
+
+        console.print("\n" + "─" * 50 + "\n")
+
+        # Example 4: Service Appointment
+        console.print("[bold yellow]Example 4: Service Appointment Booking[/bold yellow]")
+        console.print(
+            "[dim]Demonstrates: string validation, radio selection, boolean, datetime format[/dim]"
+        )
+        result = await agent.get_resource("elicitation://service-appointment")
+
+        if result_text := get_resource_text(result):
+            appointment_panel = Panel(
+                result_text, title="🔧 Appointment Confirmed", border_style="magenta", expand=False
+            )
+            console.print(appointment_panel)
+
+        console.print("\n[bold green]✅ Demo Complete![/bold green]")
+        console.print("\n[bold cyan]Features Demonstrated:[/bold cyan]")
+        console.print("• [green]String validation[/green] (min/max length)")
+        console.print("• [green]Number validation[/green] (range constraints)")
+        console.print("• [green]Radio selections[/green] (enum dropdowns)")
+        console.print("• [green]Boolean selections[/green] (checkboxes)")
+        console.print("• [green]Format validation[/green] (email, URL, date, datetime)")
+        console.print("• [green]Multiline text[/green] (expandable text areas)")
+        console.print("\nThese forms demonstrate natural, user-friendly data collection patterns!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/mcp/elicitations/game_character.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+Demonstration of Custom Elicitation Handler
+
+This example demonstrates a custom elicitation handler that creates
+an interactive game character creation experience with dice rolls,
+visual gauges, and fun interactions.
+"""
+
+import asyncio
+
+# Import our custom handler from the separate module
+from game_character_handler import game_character_elicitation_handler
+from rich.console import Console
+from rich.panel import Panel
+
+from mcp_agent.core.fastagent import FastAgent
+from mcp_agent.mcp.helpers.content_helpers import get_resource_text
+
+fast = FastAgent("Game Character Creator", quiet=True)
+console = Console()
+
+
+@fast.agent(
+    "character-creator",
+    servers=["elicitation_game_server"],
+    # Register our handler from game_character_handler.py
+    elicitation_handler=game_character_elicitation_handler,
+)
+async def main():
+    """Run the game character creator with custom elicitation handler."""
+    async with fast.run() as agent:
+        console.print(
+            Panel(
+                "[bold cyan]Welcome to the Character Creation Studio![/bold cyan]\n\n"
+                "Create your hero with our magical character generator.\n"
+                "Watch as the cosmic dice determine your fate!",
+                title="🎮 Game Time 🎮",
+                border_style="magenta",
+            )
+        )
+
+        # Trigger the character creation
+        result = await agent.get_resource("elicitation://game-character")
+
+        if result_text := get_resource_text(result):
+            character_panel = Panel(
+                result_text, title="📜 Your Character 📜", border_style="green", expand=False
+            )
+            console.print(character_panel)
+
+            console.print("\n[italic]Your character is ready for adventure![/italic]")
+            console.print("[dim]The tavern door opens, and your journey begins...[/dim]\n")
+
+            # Fun ending based on character
+            if "Powerful character" in result_text:
+                console.print("⚔️  [bold]The realm trembles at your might![/bold]")
+            elif "Challenging build" in result_text:
+                console.print("🎯 [bold]True heroes are forged through adversity![/bold]")
+            else:
+                console.print("🗡️  [bold]Your legend begins now![/bold]")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/mcp/elicitations/game_character_handler.py

@@ -0,0 +1,256 @@
+"""
+Custom Elicitation Handler for Game Character Creation
+
+This module provides a whimsical custom elicitation handler that creates
+an interactive game character creation experience with dice rolls,
+visual gauges, and animated effects.
+"""
+
+import asyncio
+import random
+from typing import TYPE_CHECKING, Any, Dict
+
+from mcp.shared.context import RequestContext
+from mcp.types import ElicitRequestParams, ElicitResult
+from rich.console import Console
+from rich.progress import BarColumn, Progress, TextColumn
+from rich.prompt import Confirm
+from rich.table import Table
+
+from mcp_agent.logging.logger import get_logger
+
+if TYPE_CHECKING:
+    from mcp import ClientSession
+
+logger = get_logger(__name__)
+console = Console()
+
+
+async def game_character_elicitation_handler(
+    context: RequestContext["ClientSession", Any],
+    params: ElicitRequestParams,
+) -> ElicitResult:
+    """Custom handler that creates an interactive character creation experience."""
+    logger.info(f"Game character elicitation handler called: {params.message}")
+
+    if params.requestedSchema:
+        properties = params.requestedSchema.get("properties", {})
+        content: Dict[str, Any] = {}
+
+        console.print("\n[bold magenta]🎮 Character Creation Studio 🎮[/bold magenta]\n")
+
+        # Character name with typewriter effect
+        if "character_name" in properties:
+            console.print("[cyan]✨ Generating your character's name...[/cyan] ", end="")
+            name_prefixes = ["Hero", "Legend", "Epic", "Mighty", "Brave", "Noble"]
+            name_suffixes = ["blade", "heart", "storm", "fire", "shadow", "star"]
+
+            name = f"{random.choice(name_prefixes)}{random.choice(name_suffixes)}{random.randint(1, 999)}"
+
+            for char in name:
+                console.print(char, end="", style="bold green")
+                await asyncio.sleep(0.03)
+            console.print("\n")
+            content["character_name"] = name
+
+        # Class selection with visual menu and fate dice
+        if "character_class" in properties:
+            class_enum = properties["character_class"].get("enum", [])
+            class_names = properties["character_class"].get("enumNames", class_enum)
+
+            table = Table(title="🎯 Choose Your Destiny", show_header=False, box=None)
+            table.add_column("Option", style="cyan", width=8)
+            table.add_column("Class", style="yellow", width=20)
+            table.add_column("Description", style="dim", width=30)
+
+            descriptions = [
+                "Master of sword and shield",
+                "Wielder of arcane mysteries",
+                "Silent shadow striker",
+                "Nature's deadly archer",
+                "Holy warrior of light",
+                "Inspiring magical performer",
+            ]
+
+            for i, (cls, name, desc) in enumerate(zip(class_enum, class_names, descriptions)):
+                table.add_row(f"[{i + 1}]", name, desc)
+
+            console.print(table)
+
+            # Dramatic fate dice roll
+            console.print("\n[bold yellow]🎲 The Fates decide your path...[/bold yellow]")
+            for _ in range(8):
+                dice_face = random.choice(["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"])
+                console.print(f"\r  Rolling... {dice_face}", end="")
+                await asyncio.sleep(0.2)
+
+            fate_roll = random.randint(1, 6)
+            selected_idx = (fate_roll - 1) % len(class_enum)
+            console.print(f"\n  🎲 Fate dice: [bold red]{fate_roll}[/bold red]!")
+            console.print(
+                f"✨ Destiny has chosen: [bold yellow]{class_names[selected_idx]}[/bold yellow]!\n"
+            )
+            content["character_class"] = class_enum[selected_idx]
+
+        # Stats rolling with animated progress bars and cosmic effects
+        stat_names = ["strength", "intelligence", "dexterity", "charisma"]
+        stats_info = {
+            "strength": {"emoji": "💪", "desc": "Physical power"},
+            "intelligence": {"emoji": "🧠", "desc": "Mental acuity"},
+            "dexterity": {"emoji": "🏃", "desc": "Agility & speed"},
+            "charisma": {"emoji": "✨", "desc": "Personal magnetism"},
+        }
+
+        console.print("[bold]🌟 Rolling cosmic dice for your abilities...[/bold]\n")
+
+        with Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(bar_width=25, style="cyan", complete_style="green"),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            console=console,
+        ) as progress:
+            for stat in stat_names:
+                if stat in properties:
+                    # Roll 3d6 for classic D&D feel with bonus potential
+                    rolls = [random.randint(1, 6) for _ in range(3)]
+                    total = sum(rolls)
+
+                    # Add cosmic bonus chance
+                    if random.random() < 0.15:  # 15% chance for cosmic boost
+                        cosmic_bonus = random.randint(1, 3)
+                        total = min(18, total + cosmic_bonus)
+                        cosmic_text = f" ✨+{cosmic_bonus} COSMIC✨"
+                    else:
+                        cosmic_text = ""
+
+                    stat_info = stats_info.get(stat, {"emoji": "📊", "desc": stat.title()})
+                    task = progress.add_task(
+                        f"{stat_info['emoji']} {stat.capitalize()}: {stat_info['desc']}", total=18
+                    )
+
+                    # Animate the progress bar with suspense
+                    for i in range(total + 1):
+                        progress.update(task, completed=i)
+                        await asyncio.sleep(0.04)
+
+                    content[stat] = total
+                    console.print(
+                        f"   🎲 Rolled: {rolls} = [bold green]{total}[/bold green]{cosmic_text}"
+                    )
+
+        # Lucky dice legendary challenge
+        if "lucky_dice" in properties:
+            console.print("\n" + "=" * 60)
+            console.print("[bold yellow]🎰 LEGENDARY CHALLENGE: Lucky Dice! 🎰[/bold yellow]")
+            console.print("The ancient dice of fortune whisper your name...")
+            console.print("Do you dare tempt fate for legendary power?")
+            console.print("=" * 60)
+
+            # Epic dice rolling sequence
+            console.print("\n[cyan]🌟 Rolling the Dice of Destiny...[/cyan]")
+
+            for i in range(15):
+                dice_faces = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
+                d20_faces = ["🎲"] * 19 + ["💎"]  # Special diamond for 20
+
+                if i < 10:
+                    face = random.choice(dice_faces)
+                else:
+                    face = random.choice(d20_faces)
+
+                console.print(f"\r  [bold]{face}[/bold] Rolling...", end="")
+                await asyncio.sleep(0.15)
+
+            final_roll = random.randint(1, 20)
+
+            if final_roll == 20:
+                console.print("\r  [bold red]💎 NATURAL 20! 💎[/bold red]")
+                console.print("  [bold green]🌟 LEGENDARY SUCCESS! 🌟[/bold green]")
+                console.print("  [gold1]You have been blessed by the gods themselves![/gold1]")
+                bonus_text = "🏆 Divine Champion status unlocked!"
+            elif final_roll >= 18:
+                console.print(f"\r  [bold yellow]⭐ {final_roll} - EPIC ROLL! ⭐[/bold yellow]")
+                bonus_text = "🎁 Epic treasure discovered!"
+            elif final_roll >= 15:
+                console.print(f"\r  [green]🎲 {final_roll} - Great success![/green]")
+                bonus_text = "🌟 Rare magical item found!"
+            elif final_roll >= 10:
+                console.print(f"\r  [yellow]🎲 {final_roll} - Good fortune.[/yellow]")
+                bonus_text = "🗡️ Modest blessing received."
+            elif final_roll == 1:
+                console.print("\r  [bold red]💀 CRITICAL FUMBLE! 💀[/bold red]")
+                bonus_text = "😅 Learning experience gained... try again!"
+            else:
+                console.print(f"\r  [dim]🎲 {final_roll} - The dice are silent.[/dim]")
+                bonus_text = "🎯 Your destiny remains unwritten."
+
+            console.print(f"  [italic]{bonus_text}[/italic]")
+            content["lucky_dice"] = final_roll >= 10
+
+        # Epic character summary with theatrical flair
+        console.print("\n" + "=" * 70)
+        console.print("[bold cyan]📜 Your Character Has Been Rolled! 📜[/bold cyan]")
+        console.print("=" * 70)
+
+        # Show character summary
+        total_stats = sum(content.get(stat, 10) for stat in stat_names if stat in content)
+
+        # Create a simple table
+        stats_table = Table(show_header=False, box=None)
+        stats_table.add_column("Label", style="cyan", width=15)
+        stats_table.add_column("Value", style="bold white")
+
+        if "character_name" in content:
+            stats_table.add_row("Name:", content["character_name"])
+        if "character_class" in content:
+            class_idx = class_enum.index(content["character_class"])
+            stats_table.add_row("Class:", class_names[class_idx])
+
+        stats_table.add_row("", "")  # Empty row for spacing
+
+        # Add stats
+        for stat in stat_names:
+            if stat in content:
+                stat_label = f"{stat.capitalize()}:"
+                stats_table.add_row(stat_label, str(content[stat]))
+
+        stats_table.add_row("", "")
+        stats_table.add_row("Total Power:", str(total_stats))
+
+        console.print(stats_table)
+
+        # Power message
+        if total_stats > 60:
+            console.print("✨ [bold gold1]The realm trembles before your might![/bold gold1] ✨")
+        elif total_stats > 50:
+            console.print("⚔️ [bold green]A formidable hero rises![/bold green] ⚔️")
+        elif total_stats < 35:
+            console.print("🎯 [bold blue]The underdog's tale begins![/bold blue] 🎯")
+        else:
+            console.print("🗡️ [bold white]Adventure awaits the worthy![/bold white] 🗡️")
+
+        # Ask for confirmation
+        console.print("\n[bold yellow]Do you accept this character?[/bold yellow]")
+        console.print("[dim]Press Enter to accept, 'n' to decline, or Ctrl+C to cancel[/dim]\n")
+
+        try:
+            accepted = Confirm.ask("Accept character?", default=True)
+
+            if accepted:
+                console.print(
+                    "\n[bold green]✅ Character accepted! Your adventure begins![/bold green]"
+                )
+                return ElicitResult(action="accept", content=content)
+            else:
+                console.print(
+                    "\n[yellow]❌ Character declined. The fates will roll again...[/yellow]"
+                )
+                return ElicitResult(action="decline")
+        except KeyboardInterrupt:
+            console.print("\n[red]❌ Character creation cancelled![/red]")
+            return ElicitResult(action="cancel")
+
+    else:
+        # No schema, return a fun message
+        content = {"response": "⚔️ Ready for adventure! ⚔️"}
+        return ElicitResult(action="accept", content=content)

mcp_agent/resources/examples/{prompting/agent.py → mcp/elicitations/tool_call.py}

@@ -3,19 +3,18 @@ import asyncio
 from mcp_agent.core.fastagent import FastAgent
 
 # Create the application
-fast = FastAgent("FastAgent Example")
+fast = FastAgent("fast-agent example")
 
 
 # Define the agent
 @fast.agent(
-    "agent",
     instruction="You are a helpful AI Agent",
-    servers=["prompts"],  # , "imgetage", "hfspace"],
+    servers=["elicitation_account_server"],
 )
-async def main() -> None:
+async def main():
     # use the --model command line switch or agent arguments to change model
     async with fast.run() as agent:
-        await agent()
+        await agent.send('***CALL_TOOL create_user_account {"service_name": "fast-agent"}')
 
 
 if __name__ == "__main__":