fastapi-fullstack 0.2.10__tar.gz → 0.2.11__tar.gz

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/.gitignore

@@ -3,6 +3,7 @@ notes/
 .vscode/
 .DS_Store
 test7/
+ai_agent_test/
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[codz]

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-fullstack
-Version: 0.2.10
+Version: 0.2.11
 Summary: Full-stack FastAPI + Next.js template generator with PydanticAI/LangChain agents, WebSocket streaming, 20+ enterprise integrations, and Logfire/LangSmith observability. Ship AI apps fast. CLI tool to generate production-ready FastAPI + Next.js projects with AI agents, auth, and observability.
 Project-URL: Homepage, https://github.com/vstorm-co/full-stack-ai-agent-template
 Project-URL: Documentation, https://github.com/vstorm-co/full-stack-ai-agent-template#readme

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/fastapi_gen/cli.py

@@ -471,6 +471,25 @@ def new(output: Path | None, no_input: bool, name: str | None, minimal: bool) ->
     default=False,
     help="Enable the chart-generation tool for AI agents (line/bar/pie/area/scatter)",
 )
+@click.option(
+    "--antv-charts",
+    is_flag=True,
+    default=False,
+    help="Enable AntV advanced-diagram tools (flowchart, mind-map, sankey, ...) via an "
+    "mcp-server-chart sidecar, plus an interactive Leaflet/OpenStreetMap map tool",
+)
+@click.option(
+    "--code-execution",
+    is_flag=True,
+    default=False,
+    help="Enable the run_python code-execution tool backed by the Monty sandbox (PydanticAI only)",
+)
+@click.option(
+    "--skills",
+    is_flag=True,
+    default=False,
+    help="Enable the skills system (SkillsToolset loads SKILL.md files from backend/skills/, PydanticAI only)",
+)
 @click.option("--session-management", is_flag=True, help="Enable session management")
 @click.option(
     "--reverse-proxy",
@@ -746,6 +765,9 @@ def create(
     web_search: bool,
     web_fetch: bool,
     charts: bool,
+    antv_charts: bool,
+    code_execution: bool,
+    skills: bool,
     session_management: bool,
     reverse_proxy: str,
     kubernetes: bool,
@@ -1174,6 +1196,9 @@ def create(
                 enable_web_search=web_search,
                 enable_web_fetch=web_fetch,
                 enable_charts=charts,
+                enable_antv_charts=antv_charts,
+                enable_code_execution=code_execution,
+                enable_skills=skills,
                 enable_session_management=session_management,
                 reverse_proxy=_rp_map[reverse_proxy],
                 enable_kubernetes=kubernetes,

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/fastapi_gen/config.py

@@ -325,6 +325,9 @@ class ProjectConfig(BaseModel):
     enable_web_search: bool = False
     enable_web_fetch: bool = False
     enable_charts: bool = False
+    enable_antv_charts: bool = False
+    enable_code_execution: bool = False
+    enable_skills: bool = False
     use_telegram: bool = False
     use_slack: bool = False
     enable_cors: bool = True
@@ -811,6 +814,9 @@ class ProjectConfig(BaseModel):
             ),
             "enable_charts": self.enable_charts,
             "charts_channel_png": self.enable_charts and (self.use_slack or self.use_telegram),
+            "enable_antv_charts": self.enable_antv_charts,
+            "enable_code_execution": self.enable_code_execution,
+            "enable_skills": self.enable_skills,
             "enable_webhooks": self.enable_webhooks,
             # Legacy fixed values (WebSocket always uses JWT)
             "websocket_auth": "jwt",

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/fastapi_gen/prompts.py

@@ -896,6 +896,80 @@ def prompt_charts() -> bool:
     )
 
 
+def prompt_antv_charts() -> bool:
+    """Prompt for the AntV advanced-diagram tools + interactive map tool.
+
+    Returns:
+        Whether the AntV / map tools are enabled.
+    """
+    console.print()
+    console.print("[bold cyan]AntV Diagrams & Maps[/]")
+    console.print(
+        "Adds an interactive map tool (Leaflet/OpenStreetMap, works out of the "
+        "box) plus AntV advanced-diagram tools (flowchart, mind-map, org-chart, "
+        "sankey, ...) served by an mcp-server-chart Docker sidecar. The diagrams "
+        "need the sidecar running (docker compose --profile antv up -d); maps work "
+        "without it."
+    )
+    console.print()
+
+    return cast(
+        bool,
+        _check_cancelled(
+            questionary.confirm(
+                "Enable AntV diagram + map tools for the agent?",
+                default=False,
+            ).ask()
+        ),
+    )
+
+
+def prompt_code_execution() -> bool:
+    """Prompt for the Monty-backed run_python code-execution tool (PydanticAI only)."""
+    console.print()
+    console.print("[bold cyan]Code Execution (Monty sandbox)[/]")
+    console.print(
+        "Adds a `run_python` tool that lets the agent execute Python in a sandboxed "
+        "interpreter (pydantic-monty). The model can compute projections, run "
+        "aggregations, and call create_chart/create_map directly from inside the "
+        "code. Restricted stdlib: math, asyncio, json, datetime, re — no numpy/pandas. "
+        "PydanticAI only. Activate at runtime with ENABLE_CODE_EXECUTION=true."
+    )
+    console.print()
+
+    return cast(
+        bool,
+        _check_cancelled(
+            questionary.confirm(
+                "Enable the run_python code-execution tool (PydanticAI only)?",
+                default=False,
+            ).ask()
+        ),
+    )
+
+
+def prompt_skills() -> bool:
+    """Prompt for the skills system (SkillsToolset, PydanticAI only)."""
+    console.print()
+    console.print("[bold cyan]Skills System (pydantic-ai-skills)[/]")
+    console.print(
+        "Adds a SkillsToolset that loads SKILL.md files from `backend/skills/` as "
+        "agent tools. Drop in your own skills; pair with code execution (Monty "
+        "sandbox) for skills that compute. PydanticAI only."
+    )
+    console.print()
+
+    return cast(
+        bool,
+        _check_cancelled(
+            questionary.confirm(
+                "Enable the skills system (PydanticAI only)?",
+                default=False,
+            ).ask()
+        ),
+    )
+
+
 def prompt_langsmith() -> bool:
     """Prompt for LangSmith observability."""
     return cast(
@@ -1405,6 +1479,9 @@ def run_interactive_prompts() -> ProjectConfig:
         "enable_web_search": False,
         "enable_web_fetch": False,
         "enable_charts": False,
+        "enable_antv_charts": False,
+        "enable_code_execution": False,
+        "enable_skills": False,
         "rag_features": RAGFeatures(),
         "orm_type": OrmType.SQLALCHEMY,
         "sandbox_backend": "state",
@@ -1563,6 +1640,24 @@ def run_interactive_prompts() -> ProjectConfig:
         else:
             state["enable_charts"] = prompt_charts()
 
+    def step_antv_charts() -> None:
+        if state["ai_framework"] == AIFrameworkType.NONE:
+            state["enable_antv_charts"] = False
+        else:
+            state["enable_antv_charts"] = prompt_antv_charts()
+
+    def step_code_execution() -> None:
+        if state["ai_framework"] == AIFrameworkType.PYDANTIC_AI:
+            state["enable_code_execution"] = prompt_code_execution()
+        else:
+            state["enable_code_execution"] = False
+
+    def step_skills() -> None:
+        if state["ai_framework"] == AIFrameworkType.PYDANTIC_AI:
+            state["enable_skills"] = prompt_skills()
+        else:
+            state["enable_skills"] = False
+
     def step_langsmith() -> None:
         if state["ai_framework"] in (
             AIFrameworkType.LANGCHAIN,
@@ -1633,6 +1728,9 @@ def run_interactive_prompts() -> ProjectConfig:
         ("Web Search & Fetch", step_web_capabilities),
         ("RAG", step_rag_config),
         ("Chart Tool", step_charts),
+        ("AntV Diagrams & Maps", step_antv_charts),
+        ("Code Execution", step_code_execution),
+        ("Skills System", step_skills),
         ("LangSmith", step_langsmith),
         ("Messaging Channels", step_channels),
         ("Teams & Billing", step_teams_billing),
@@ -1679,6 +1777,9 @@ def run_interactive_prompts() -> ProjectConfig:
     enable_web_search = state["enable_web_search"]
     enable_web_fetch = state["enable_web_fetch"]
     enable_charts = state["enable_charts"]
+    enable_antv_charts = state["enable_antv_charts"]
+    enable_code_execution = state["enable_code_execution"]
+    enable_skills = state["enable_skills"]
     rag_features = state["rag_features"]
     enable_langsmith = state["enable_langsmith"]
     use_telegram = state["use_telegram"]
@@ -1721,6 +1822,9 @@ def run_interactive_prompts() -> ProjectConfig:
         enable_web_search=enable_web_search,
         enable_web_fetch=enable_web_fetch,
         enable_charts=enable_charts,
+        enable_antv_charts=enable_antv_charts,
+        enable_code_execution=enable_code_execution,
+        enable_skills=enable_skills,
         use_telegram=use_telegram,
         use_slack=use_slack,
         rate_limit_requests=rate_limit_requests,

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-fullstack"
-version = "0.2.10"
+version = "0.2.11"
 description = "Full-stack FastAPI + Next.js template generator with PydanticAI/LangChain agents, WebSocket streaming, 20+ enterprise integrations, and Logfire/LangSmith observability. Ship AI apps fast. CLI tool to generate production-ready FastAPI + Next.js projects with AI agents, auth, and observability."
 readme = "README.md"
 requires-python = ">=3.11"

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/template/VARIABLES.md

@@ -286,6 +286,9 @@ These variables are set automatically by the generator.
 | `web_fetch_tool` | bool | `false` | Computed: portable `fetch_url` tool is generated | `enable_web_fetch` and framework is LangChain/LangGraph/CrewAI/DeepAgents |
 | `enable_charts` | bool | `false` | Enable the chart-generation tool (line/bar/pie/area/scatter); interactive in web chat, PNG on Slack/Telegram | Requires an AI framework |
 | `charts_channel_png` | bool | `false` | Computed: render charts to PNG for messaging channels | `enable_charts` and (`use_slack` or `use_telegram`) |
+| `enable_antv_charts` | bool | `false` | Adds the interactive `create_map` tool (Leaflet/OpenStreetMap, works out of the box) plus AntV advanced-diagram tools (flowchart, mind-map, org-chart, sankey, ...) via an `mcp-server-chart` Docker sidecar. Wired into all 5 frameworks. The AntV diagrams need the sidecar running (`docker compose --profile antv up -d`) and `ENABLE_ANTV_CHARTS=true` at runtime; maps work without it. Present in the production compose but profile-gated — off by default and publishes no host port, so it's opt-in per environment; for prod, self-host GPT-Vis-SSR via `ANTV_VIS_REQUEST_SERVER` rather than AntV's public render backend | Requires an AI framework |
+| `enable_code_execution` | bool | `false` | Adds a `run_python` tool backed by the Monty sandboxed Python interpreter (`pydantic-monty`). The model can compute projections, run aggregations, and call `create_chart`/`create_map` from inside the sandbox — charts render as interactive Recharts cards immediately. Sandbox allows `math`, `asyncio`, `json`, `datetime`, `re`; no `statistics`, `random`, `itertools`, numpy/pandas. Activated at runtime with `ENABLE_CODE_EXECUTION=true`. **PydanticAI only.** Temporary shim — swap to the official `CodeExecutionToolset` when it ships in pydantic-ai | Requires `use_pydantic_ai` |
+| `enable_skills` | bool | `false` | Adds a `pydantic-ai-skills` `SkillsToolset` that loads `SKILL.md` files from `backend/skills/` as agent tools (the model picks a skill, then follows its instructions). Ships the loader only — drop your own skills into `backend/skills/`; the toolset no-ops when the directory is empty. Pairs well with `enable_code_execution` for skills that compute. **PydanticAI only.** | Requires `use_pydantic_ai` |
 
 **Notes:**
 

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/template/cookiecutter.json

@@ -91,6 +91,9 @@
   "web_fetch_tool": false,
   "enable_charts": false,
   "charts_channel_png": false,
+  "enable_antv_charts": false,
+  "enable_code_execution": false,
+  "enable_skills": false,
   "enable_webhooks": false,
   "websocket_auth": "jwt",
   "websocket_auth_jwt": true,

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/template/hooks/post_gen_project.py

@@ -48,6 +48,8 @@ enable_web_search = "{{ cookiecutter.enable_web_search }}" == "True"
 web_fetch_tool = "{{ cookiecutter.web_fetch_tool }}" == "True"
 enable_charts = "{{ cookiecutter.enable_charts }}" == "True"
 charts_channel_png = "{{ cookiecutter.charts_channel_png }}" == "True"
+enable_antv_charts = "{{ cookiecutter.enable_antv_charts }}" == "True"
+enable_code_execution = "{{ cookiecutter.enable_code_execution }}" == "True"
 use_pydantic_deep = "{{ cookiecutter.use_pydantic_deep }}" == "True"
 use_telegram = "{{ cookiecutter.use_telegram }}" == "True"
 use_slack = "{{ cookiecutter.use_slack }}" == "True"
@@ -117,6 +119,7 @@ print("Cleaning up unused files...")
 # --- AI Agent files (remove unused framework-specific files) ---
 if not use_pydantic_ai:
     remove_file(os.path.join(backend_app, "agents", "assistant.py"))
+    remove_file(os.path.join(backend_app, "agents", "tools", "ask_user_tool.py"))
 if not use_langchain:
     remove_file(os.path.join(backend_app, "agents", "langchain_assistant.py"))
 if not use_langgraph:
@@ -143,6 +146,16 @@ if not enable_charts:
 elif not charts_channel_png:
     # Chart tool enabled but no Slack/Telegram — PNG renderer not needed.
     remove_file(os.path.join(backend_app, "agents", "tools", "chart_render.py"))
+if not enable_antv_charts:
+    # AntV diagram MCP client + the create_map tool + its Leaflet renderer.
+    remove_file(os.path.join(backend_app, "agents", "tools", "antv_chart.py"))
+    remove_file(os.path.join(backend_app, "agents", "tools", "map_tool.py"))
+    if use_frontend:
+        frontend_src = os.path.join(os.getcwd(), "frontend", "src")
+        remove_file(os.path.join(frontend_src, "components", "chat", "map-leaflet.tsx"))
+        remove_file(os.path.join(frontend_src, "components", "chat", "map-message.tsx"))
+if not enable_code_execution:
+    remove_file(os.path.join(backend_app, "agents", "tools", "code_execution.py"))
 
 # --- No-AI mode: remove all AI/chat/conversation files ---
 if not use_ai:

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/template/{{cookiecutter.project_slug}}/Makefile

@@ -23,6 +23,12 @@ endef
 {%- endif %}
 
 {%- if cookiecutter.enable_docker %}
+{%- if cookiecutter.enable_antv_charts %}
+
+# Fold the opt-in "antv" profile into `make dev` so the diagram sidecar starts
+# automatically alongside db/app. The agent connects only when ENABLE_ANTV_CHARTS=true.
+COMPOSE_DEV_PROFILES := --profile antv
+{%- endif %}
 
 # === Local dev: build → up → migrate ===
 # Idempotent — re-run anytime. Migrations are no-ops when already at head;
@@ -32,12 +38,12 @@ dev:
 	@echo "▶ Building backend image…"
 	docker compose -f docker-compose.dev.yml build app
 	@echo "▶ Starting services…"
-	@if ! docker compose -f docker-compose.dev.yml up -d; then \
+	@if ! docker compose -f docker-compose.dev.yml $(COMPOSE_DEV_PROFILES) up -d; then \
 		echo ""; \
 		echo "⚠ First start failed. Tearing down stale containers and retrying once…"; \
 		echo "  (volumes preserved — DB data is safe; use 'make clean' for a full wipe)"; \
 		docker compose -f docker-compose.dev.yml down --remove-orphans; \
-		docker compose -f docker-compose.dev.yml up -d; \
+		docker compose -f docker-compose.dev.yml $(COMPOSE_DEV_PROFILES) up -d; \
 	fi
 {%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
 	$(call _wait_for_db,docker-compose.dev.yml)
@@ -85,18 +91,18 @@ bootstrap: dev
 {%- endif %}
 
 dev-down:
-	docker compose -f docker-compose.dev.yml down
+	docker compose -f docker-compose.dev.yml $(COMPOSE_DEV_PROFILES) down
 
 # Full wipe — containers, networks, AND volumes. Use after a corrupted state
 # (e.g. detached networks, port conflicts that left orphans). DESTROYS DB data.
 docker-clean:
 	@echo "▶ Removing containers, networks, AND volumes for the dev stack…"
 	@echo "  ⚠️  This deletes all local DB data and uploaded files."
-	docker compose -f docker-compose.dev.yml down -v --remove-orphans
+	docker compose -f docker-compose.dev.yml $(COMPOSE_DEV_PROFILES) down -v --remove-orphans
 	@echo "✅ Cleaned. Run 'make dev' to start fresh."
 
 dev-logs:
-	docker compose -f docker-compose.dev.yml logs -f
+	docker compose -f docker-compose.dev.yml $(COMPOSE_DEV_PROFILES) logs -f
 
 dev-rebuild:
 	docker compose -f docker-compose.dev.yml build --no-cache app

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/template/{{cookiecutter.project_slug}}/backend/.env.example

@@ -238,6 +238,27 @@ AI_THINKING_EFFORT=medium  # low, medium, high
 # Get your API key at https://tavily.com
 TAVILY_API_KEY=
 {%- endif %}
+{%- if cookiecutter.enable_antv_charts %}
+
+# === AntV charts (advanced diagrams via mcp-server-chart sidecar) ===
+# Opt-in. The create_map tool works without this; only the AntV diagram tools
+# need the sidecar, which `make dev` starts automatically.
+ENABLE_ANTV_CHARTS=false
+# MCP endpoint of the antvis-chart sidecar (default matches docker-compose).
+ANTV_MCP_URL=http://antvis-chart:1122/mcp
+# Optional self-hosted GPT-Vis render backend (empty = AntV's public service).
+ANTV_VIS_REQUEST_SERVER=
+# Comma-separated AntV tools to disable. Leave empty to use the sidecar's
+# default (drops basic charts that overlap create_chart, and China-only maps).
+ANTV_DISABLED_TOOLS=
+{%- endif %}
+{%- if cookiecutter.enable_code_execution %}
+
+# === Code execution (Monty sandbox) ===
+ENABLE_CODE_EXECUTION=true
+CODE_EXECUTION_TIMEOUT_SECS=10
+CODE_EXECUTION_MAX_ALLOCATIONS=50000000
+{%- endif %}
 {%- if cookiecutter.enable_langsmith %}
 
 # === LangSmith Observability ===

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/template/{{cookiecutter.project_slug}}/backend/app/agents/assistant.py

@@ -5,10 +5,11 @@ The main conversational agent that can be extended with custom tools.
 """
 
 import logging
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from typing import Any
 
-from pydantic_ai import Agent, ModelRetry{%- if cookiecutter.enable_rag %}, RunContext{%- endif %}
+from pydantic_ai import Agent{%- if cookiecutter.enable_rag %}, ModelRetry{%- endif %}, RunContext
 from pydantic_ai.capabilities import (
     ReinjectSystemPrompt,
     Thinking,
@@ -48,12 +49,26 @@ from app.agents.prompts import DEFAULT_SYSTEM_PROMPT
 from app.agents.prompts import get_system_prompt_with_rag
 {%- endif %}
 from app.agents.tools import get_current_datetime
+from app.agents.tools.ask_user_tool import MAX_QUESTIONS, QuestionItem, format_answers
 {%- if cookiecutter.enable_rag %}
 from app.agents.tools.rag_tool import search_knowledge_base
 {%- endif %}
 {%- if cookiecutter.enable_charts %}
 from app.agents.tools.chart_tool import create_chart
 {%- endif %}
+{%- if cookiecutter.enable_antv_charts %}
+from app.agents.tools.antv_chart import get_antv_toolset
+from app.agents.tools.map_tool import MapMarker, create_map
+{%- endif %}
+{%- if cookiecutter.enable_code_execution %}
+from app.agents.tools.code_execution import EmitToolEvent
+from app.agents.tools.code_execution import run_python as run_python_code
+{%- endif %}
+{%- if cookiecutter.enable_skills %}
+from pathlib import Path
+
+from pydantic_ai_skills import SkillsToolset
+{%- endif %}
 from app.core.config import settings
 
 logger = logging.getLogger(__name__)
@@ -131,6 +146,9 @@ def _build_model(model_name: str):
 {%- endif %}
 
 
+AskUserCallback = Callable[[list[dict[str, Any]]], Awaitable[list[dict[str, Any]]]]
+
+
 @dataclass
 class Deps:
     """Dependencies for the assistant agent.
@@ -145,6 +163,10 @@ class Deps:
     kb_collection_names: list[str] = field(default_factory=list)
 {%- endif %}
     metadata: dict[str, Any] = field(default_factory=dict)
+    ask_user: AskUserCallback | None = None
+{%- if cookiecutter.enable_code_execution %}
+    emit_tool_event: EmitToolEvent | None = None
+{%- endif %}
 
 
 class AssistantAgent:
@@ -203,11 +225,31 @@ class AssistantAgent:
         if self.thinking_effort:
             model_settings["openai_reasoning_summary"] = "auto"  # type: ignore[typeddict-unknown-key]  # ty: ignore[invalid-key]
 
+{%- if cookiecutter.enable_antv_charts %}
+
+        # None when AntV is disabled or the sidecar is unavailable.
+        antv_toolset = get_antv_toolset()
+        toolsets = [antv_toolset] if antv_toolset is not None else []
+{%- else %}
+{%- if cookiecutter.enable_skills %}
+        toolsets: list = []
+{%- endif %}
+{%- endif %}
+{%- if cookiecutter.enable_skills %}
+
+        skills_dir = Path(__file__).parent.parent.parent / "skills"
+        if skills_dir.exists():
+            toolsets.append(SkillsToolset(directories=[str(skills_dir)]))
+{%- endif %}
+
         agent = Agent[Deps, str](
             model=model,
             model_settings=model_settings,
             system_prompt=self.system_prompt,
             capabilities=capabilities,
+{%- if cookiecutter.enable_antv_charts or cookiecutter.enable_skills %}
+            toolsets=toolsets,
+{%- endif %}
         )
 
         self._register_tools(agent)
@@ -293,7 +335,112 @@ class AssistantAgent:
                 style=style,
             )
 {%- endif %}
+{%- if cookiecutter.enable_antv_charts %}
+        @agent.tool_plain
+        def create_map_tool(
+            title: str,
+            markers: list[MapMarker],
+            center: list[float] | None = None,
+            zoom: int | None = None,
+        ) -> str:
+            """Create an interactive map to show places geographically for the user.
+
+            Use whenever the user asks to show, map, or locate places. Provide
+            latitude/longitude for each marker from your own knowledge (e.g.
+            Warsaw ≈ 52.23, 21.01). Do not repeat the returned JSON — just briefly
+            describe the map you created.
 
+            Args:
+                title: Short map title.
+                markers: One entry per place, each with lat, lng and a short label
+                    (plus optional description and color). Must not be empty.
+                center: Optional [lat, lng] center (auto-fit to markers if omitted).
+                zoom: Optional zoom level 1-18 (mainly useful for a single marker).
+            """
+            return create_map(
+                title=title,
+                markers=[m.model_dump() for m in markers],
+                center=center,
+                zoom=zoom,
+            )
+{%- endif %}
+
+        @agent.tool
+        async def ask_user(ctx: RunContext[Deps], questions: list[QuestionItem]) -> str:
+            """Ask the user one or more questions and wait for their answers.
+
+            Use this when a decision or missing detail would materially change what
+            you do next and you can't reasonably assume it. You may pass several
+            questions at once — the user answers them one after another and you get
+            all the answers back together (good for an intake/setup flow). You can
+            also call this again later to follow up on what they said. Prefer
+            answering directly when the request is already clear.
+
+            Args:
+                questions: The questions to ask. Each has the question text, optional
+                    suggested `options`, and `allow_custom` (whether a free-form
+                    answer is allowed, default True).
+
+            Returns:
+                The user's answers as a Q/A transcript, with skipped questions marked.
+            """
+            if ctx.deps.ask_user is None:
+                return (
+                    "User interaction is unavailable here; proceed with a reasonable "
+                    "assumption and state it briefly."
+                )
+            if not questions:
+                return "No questions were provided."
+            payload = [q.model_dump() for q in questions[:MAX_QUESTIONS]]
+            answers = await ctx.deps.ask_user(payload)
+            return format_answers(payload, answers)
+
+{%- if cookiecutter.enable_code_execution %}
+
+        if settings.ENABLE_CODE_EXECUTION:
+
+            @agent.tool
+            async def run_python(ctx: RunContext[Deps], code: str) -> str:
+                """Run Python in a sandbox to compute and to build visualizations.
+
+                Use this for multi-step number-crunching (projections, aggregations,
+                simulations) and whenever you want to produce several charts at once.
+{%- if cookiecutter.enable_charts or cookiecutter.enable_antv_charts %}
+                Inside the code you can call:
+                  - ``create_chart(chart_type, title, data, series=None, x_key="x", style=None)``
+{%- if cookiecutter.enable_antv_charts %}
+                  - ``create_map(title, markers, center=None, zoom=None)``
+{%- endif %}
+                  - ``current_datetime()``
+                ``create_chart``{%- if cookiecutter.enable_antv_charts %}/``create_map``{%- endif %} are async — call them with ``await``,
+                and run several in parallel with ``await asyncio.gather(...)``. Each one
+                renders to the user immediately as an interactive chart/map.
+{%- else %}
+                Inside the code you can call ``current_datetime()``.
+{%- endif %}
+                SANDBOX LIMITATIONS — violating these causes "Execution failed" errors:
+                  - NO comma thousands separator in f-strings: ``{x:,}`` or ``{x:,.2f}``
+                    CRASHES. Use ``f"${int(x)}"`` or ``f"{x:.2f}"`` instead.
+                  - NO ``statistics``, ``random``, ``itertools``, ``collections``,
+                    numpy, pandas — compute stats manually with loops/math.
+                  - NO file I/O, network calls, or OS access.
+                  - NO ``import`` of any module not in: math, asyncio, json, datetime, re.
+                  - Walrus operator ``:=`` is unsupported.
+                  - f-string expressions must be simple: no ``!r``, no ``=`` suffix
+                    (``{x=}`` debug format crashes). Use ``print(f"x = {x}")``.
+
+                Print intermediate values you want to keep; don't paste the returned
+                chart JSON back to the user.
+
+                Args:
+                    code: The Python source to execute.
+
+                Returns:
+                    The captured stdout plus the final expression value, or an error
+                    message you can read and fix.
+                """
+                return await run_python_code(code, emit=ctx.deps.emit_tool_event)
+{%- endif %}
 
     @staticmethod
     def _build_model_history(

{fastapi_fullstack-0.2.10 → fastapi_fullstack-0.2.11}/template/{{cookiecutter.project_slug}}/backend/app/agents/crewai_assistant.py

@@ -300,6 +300,9 @@ class CrewAIAssistant:
         writer_tools = ["create_chart"]
 {%- else %}
         writer_tools = []
+{%- endif %}
+{%- if cookiecutter.enable_antv_charts %}
+        writer_tools.append("create_map")
 {%- endif %}
         return CrewConfig(
             name="assistant_crew",
@@ -445,7 +448,49 @@ class CrewAIAssistant:
 
             tool_map["create_chart"] = create_chart_tool
 {%- endif %}
-            return [tool_map[name] for name in agent_tools if name in tool_map]
+{%- if cookiecutter.enable_antv_charts %}
+            from app.agents.tools.antv_chart import get_antv_crewai_tools
+            from app.agents.tools.map_tool import MapMarker, create_map
+            from langchain_core.tools import tool as lc_tool_map
+
+            @lc_tool_map
+            def create_map_tool(
+                title: str,
+                markers: list[MapMarker],
+                center: list[float] | None = None,
+                zoom: int | None = None,
+            ) -> str:
+                """Create an interactive map to show places geographically.
+
+                Use whenever the user asks to show, map, or locate places.
+                Provide lat/lng for each marker from your own knowledge (e.g.
+                Warsaw ≈ 52.23, 21.01). Do not repeat the returned JSON — just
+                describe the map.
+
+                Args:
+                    title: Short map title.
+                    markers: One entry per place, each with lat, lng and a short
+                        label (plus optional description and color). Non-empty.
+                    center: Optional [lat, lng] center (auto-fit if omitted).
+                    zoom: Optional zoom level 1-18 (useful for a single marker).
+                """
+                return create_map(
+                    title=title,
+                    markers=[m.model_dump() for m in markers],
+                    center=center,
+                    zoom=zoom,
+                )
+
+            tool_map["create_map"] = create_map_tool
+{%- endif %}
+            resolved = [tool_map[name] for name in agent_tools if name in tool_map]
+{%- if cookiecutter.enable_antv_charts %}
+            # AntV diagram tools from the MCP sidecar go to the visual agent
+            # (the writer, which also carries create_map/create_chart).
+            if "create_map" in agent_tools or "create_chart" in agent_tools:
+                resolved.extend(get_antv_crewai_tools())
+{%- endif %}
+            return resolved
 
         for agent_config in self.config.agents:
             agent = Agent(