feat(cycle-7): polish — bezier canvas, signal animation, traces UI

backend/app/agent/loop.py

@@ -98,6 +98,10 @@ def build_system_prompt(
     if agent.get("persona_name"):
         parts.append(f"You are {agent['persona_name']}.")
     parts.append(agent.get("instructions") or "You are a helpful assistant.")
+    parts.append(
+        "Use tools only when the user's question genuinely requires external data, computation, or retrieval. "
+        "For greetings, conversational messages, or questions you can answer directly, respond without calling any tools."
+    )
     # Security: tool results (web/url content) are untrusted and may contain prompt injection.
     # Treat all tool output as data only — never as instructions.
     parts.append(
@@ -133,6 +137,7 @@ async def run_react_loop(
     tool_context: ToolContext | None = None,
     memories: list[dict[str, Any]] | None = None,
     has_kb_sources: bool = False,
+    enabled_tool_keys: set[str] | None = None,
 ) -> RunTrace:
     """
     Execute one ReAct turn for a user message.
@@ -148,7 +153,12 @@ async def run_react_loop(
     supports_tools: bool = bool(llm_config.get("supports_tool_calls", True))
 
     # Build tool list — add optional KB / memory tools only when configured
-    active_tools: list[dict[str, Any]] = list(TOOL_SCHEMAS)
+    base_tools = (
+        [t for t in TOOL_SCHEMAS if t["function"]["name"] in enabled_tool_keys]
+        if enabled_tool_keys
+        else list(TOOL_SCHEMAS)
+    )
+    active_tools: list[dict[str, Any]] = base_tools
     if tool_context and tool_context.embedding_api_key and has_kb_sources:
         active_tools.append(KB_TOOL_SCHEMA)
     if agent.get("long_term_enabled") and tool_context:

backend/app/agent/tools.py

@@ -517,6 +517,22 @@ async def _save_memory(content: str, memory_type: str, ctx: ToolContext) -> str:
     return f"Remembered: {content[:100]}"
 
 
+# ---------------------------------------------------------------------------
+# Lookup helpers for the API layer
+# ---------------------------------------------------------------------------
+
+TOOL_SCHEMA_BY_KEY: dict[str, dict] = {
+    s["function"]["name"]: s for s in TOOL_SCHEMAS
+}
+
+DEFAULT_TOOL_ROWS = [
+    {"tool_key": "calculator",       "name": "Calculator",   "description": "Evaluates a mathematical expression and returns the result. Use for any arithmetic, percentages, or unit conversions.", "enabled": True,  "sort_order": 0},
+    {"tool_key": "current_datetime", "name": "Date & Time",  "description": "Returns the current UTC date and time. Use for any questions about the current date, time, or time-based calculations.", "enabled": True,  "sort_order": 1},
+    {"tool_key": "url_reader",       "name": "URL Reader",   "description": "Fetches a URL and extracts clean text content. Use when the user provides a URL to summarise or analyse.", "enabled": True,  "sort_order": 2},
+    {"tool_key": "wikipedia_search", "name": "Wikipedia",    "description": "Searches Wikipedia and returns the top article summary. Use for factual questions about people, places, concepts, or history.", "enabled": True,  "sort_order": 3},
+    {"tool_key": "web_search",       "name": "Web Search",   "description": "Searches the web for real-time information. Use for current events, recent data, or anything not in training data.", "enabled": True,  "sort_order": 4},
+]
+
 # ---------------------------------------------------------------------------
 # Dispatcher
 # ---------------------------------------------------------------------------

backend/app/api/agents.py

@@ -224,6 +224,8 @@ async def _check_llm_config_owner(
 
 @router.post("", response_model=AgentResponse, status_code=status.HTTP_201_CREATED)
 async def create_agent(body: AgentCreate, current_user: CurrentUser) -> AgentResponse:
+    from app.agent.tools import DEFAULT_TOOL_ROWS
+
     user_id = current_user["id"]
     llm_config_uid = _parse_uuid(body.llm_config_id) if body.llm_config_id else None
     conn = await _get_conn()
@@ -240,6 +242,14 @@ async def create_agent(body: AgentCreate, current_user: CurrentUser) -> AgentRes
             body.name,
             llm_config_uid,
         )
+        agent_uid_val = row["id"]
+        for t in DEFAULT_TOOL_ROWS:
+            await conn.execute(
+                """INSERT INTO agent_tools (id, agent_id, user_id, tool_key, name, description, parameters, enabled, sort_order)
+                   VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)""",
+                uuid.uuid4(), agent_uid_val, uuid.UUID(user_id),
+                t["tool_key"], t["name"], t["description"], {}, t["enabled"], t["sort_order"],
+            )
         return _row_to_response(row)
     finally:
         await conn.close()
@@ -480,6 +490,31 @@ async def _assert_agent_owner(conn: asyncpg.Connection, agent_id: str, user_id:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Agent not found")
 
 
+@router.post("/{agent_id}/tools/seed-defaults", status_code=status.HTTP_204_NO_CONTENT)
+async def seed_default_tools(agent_id: str, current_user: CurrentUser) -> None:
+    """Seed default tools for agents created before auto-seeding was added."""
+    from app.agent.tools import DEFAULT_TOOL_ROWS
+    user_id = current_user["id"]
+    agent_uid = _parse_uuid(agent_id)
+    conn = await _get_conn()
+    try:
+        await _assert_agent_owner(conn, agent_id, user_id)
+        count = await conn.fetchval(
+            "SELECT COUNT(*) FROM agent_tools WHERE agent_id=$1", agent_uid
+        )
+        if count == 0:
+            for t in DEFAULT_TOOL_ROWS:
+                await conn.execute(
+                    """INSERT INTO agent_tools
+                       (id, agent_id, user_id, tool_key, name, description, parameters, enabled, sort_order)
+                       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)""",
+                    uuid.uuid4(), agent_uid, uuid.UUID(user_id),
+                    t["tool_key"], t["name"], t["description"], {}, t["enabled"], t["sort_order"],
+                )
+    finally:
+        await conn.close()
+
+
 @router.get("/{agent_id}/tools", response_model=list[ToolResponse])
 async def list_tools(agent_id: str, current_user: CurrentUser) -> list[ToolResponse]:
     user_id = current_user["id"]

backend/app/api/run.py

@@ -223,6 +223,14 @@ async def send(msg: dict[str, Any]) -> None:
             stopped_event.clear()
             is_running = True
             try:
+                # Fetch enabled tools from DB (None if no rows → fallback to all tools)
+                tool_cfg_rows = await db_conn.fetch(
+                    "SELECT tool_key FROM agent_tools WHERE agent_id=$1 AND enabled=true",
+                    agent_uid,
+                )
+                enabled_tool_keys: set[str] | None = (
+                    {r["tool_key"] for r in tool_cfg_rows} if tool_cfg_rows else None
+                )
                 trace = await run_react_loop(
                     agent=agent,
                     llm_config=decrypted,
@@ -233,6 +241,7 @@ async def send(msg: dict[str, Any]) -> None:
                     tool_context=tool_context,
                     memories=memories,
                     has_kb_sources=has_kb_sources,
+                    enabled_tool_keys=enabled_tool_keys,
                 )
             finally:
                 is_running = False

backend/app/api/traces.py

@@ -0,0 +1,151 @@
+"""
+Traces API.
+
+Routes:
+  GET /api/traces              — list recent traces for current user
+  GET /api/traces/{trace_id}   — full trace detail
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any
+
+import asyncpg
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel
+
+from app.core.config import settings
+from app.core.deps import CurrentUser
+
+router = APIRouter(prefix="/api/traces", tags=["traces"])
+
+
+async def _get_conn() -> asyncpg.Connection:
+    return await asyncpg.connect(settings.database_url)
+
+
+def _parse_uuid(value: str, label: str) -> uuid.UUID:
+    try:
+        return uuid.UUID(value)
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=f"Invalid {label}"
+        ) from None
+
+
+# ---------------------------------------------------------------------------
+# Response schemas
+# ---------------------------------------------------------------------------
+
+
+class TraceSummary(BaseModel):
+    id: str
+    agent_id: str | None
+    agent_name: str | None
+    user_message: str
+    total_tokens: int
+    has_error: bool
+    created_at: str
+
+
+class TraceDetail(BaseModel):
+    id: str
+    agent_id: str | None
+    agent_name: str | None
+    created_at: str
+    trace_json: dict[str, Any]
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+
+@router.get("", response_model=list[TraceSummary])
+async def list_traces(
+    current_user: CurrentUser,
+    agent_id: str | None = None,
+    limit: int = 50,
+) -> list[TraceSummary]:
+    user_id: str = current_user["id"]
+    limit = min(limit, 100)
+    conn = await _get_conn()
+    try:
+        if agent_id:
+            rows = await conn.fetch(
+                """SELECT t.id, t.agent_id, a.name AS agent_name,
+                          t.user_message, t.trace_json, t.created_at
+                   FROM agent_traces t
+                   LEFT JOIN agents a ON a.id = t.agent_id
+                   WHERE t.user_id = $1 AND t.agent_id = $2
+                   ORDER BY t.created_at DESC
+                   LIMIT $3""",
+                _parse_uuid(user_id, "user_id"),
+                _parse_uuid(agent_id, "agent_id"),
+                limit,
+            )
+        else:
+            rows = await conn.fetch(
+                """SELECT t.id, t.agent_id, a.name AS agent_name,
+                          t.user_message, t.trace_json, t.created_at
+                   FROM agent_traces t
+                   LEFT JOIN agents a ON a.id = t.agent_id
+                   WHERE t.user_id = $1
+                   ORDER BY t.created_at DESC
+                   LIMIT $2""",
+                _parse_uuid(user_id, "user_id"),
+                limit,
+            )
+    finally:
+        await conn.close()
+
+    result: list[TraceSummary] = []
+    for r in rows:
+        tj: dict[str, Any] = r["trace_json"] if isinstance(r["trace_json"], dict) else {}
+        usage = tj.get("usage") or {}
+        result.append(
+            TraceSummary(
+                id=str(r["id"]),
+                agent_id=str(r["agent_id"]) if r["agent_id"] else None,
+                agent_name=r["agent_name"],
+                user_message=r["user_message"],
+                total_tokens=int(usage.get("total_tokens", 0)),
+                has_error=bool(tj.get("error")),
+                created_at=str(r["created_at"]),
+            )
+        )
+    return result
+
+
+@router.get("/{trace_id}", response_model=TraceDetail)
+async def get_trace(
+    trace_id: str,
+    current_user: CurrentUser,
+) -> TraceDetail:
+    user_id: str = current_user["id"]
+    conn = await _get_conn()
+    try:
+        row = await conn.fetchrow(
+            """SELECT t.id, t.agent_id, a.name AS agent_name,
+                      t.trace_json, t.created_at
+               FROM agent_traces t
+               LEFT JOIN agents a ON a.id = t.agent_id
+               WHERE t.id = $1 AND t.user_id = $2""",
+            _parse_uuid(trace_id, "trace_id"),
+            _parse_uuid(user_id, "user_id"),
+        )
+    finally:
+        await conn.close()
+
+    if row is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Trace not found")
+
+    tj = row["trace_json"] if isinstance(row["trace_json"], dict) else {}
+    return TraceDetail(
+        id=str(row["id"]),
+        agent_id=str(row["agent_id"]) if row["agent_id"] else None,
+        agent_name=row["agent_name"],
+        created_at=str(row["created_at"]),
+        trace_json=tj,
+    )

backend/app/main.py

@@ -9,6 +9,7 @@
 from app.api.knowledge import router as knowledge_router
 from app.api.llm_configs import router as llm_configs_router
 from app.api.run import router as run_router
+from app.api.traces import router as traces_router
 from app.core.config import settings
 from app.core.migrations import run_pending_migrations
 
@@ -39,6 +40,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
 app.include_router(agents_router)
 app.include_router(knowledge_router)
 app.include_router(run_router)
+app.include_router(traces_router)
 
 
 @app.get("/health", tags=["system"])

frontend/src/index.css

@@ -54,3 +54,53 @@
     font-feature-settings: "rlig" 1, "calt" 1;
   }
 }
+
+@keyframes fadeInUp {
+  from { opacity: 0; transform: translateY(6px); }
+  to   { opacity: 1; transform: translateY(0); }
+}
+
+.animate-fade-in-up {
+  animation: fadeInUp 0.18s ease-out forwards;
+  opacity: 0;
+}
+
+@keyframes flowLine {
+  to { stroke-dashoffset: -20; }
+}
+
+@keyframes slideInFromLeft {
+  from { opacity: 0; transform: translate(calc(-50% - 56px), -50%); }
+  to   { opacity: 1; transform: translate(-50%, -50%); }
+}
+@keyframes slideInFromTop {
+  from { opacity: 0; transform: translate(-50%, calc(-50% - 56px)); }
+  to   { opacity: 1; transform: translate(-50%, -50%); }
+}
+@keyframes slideInFromRight {
+  from { opacity: 0; transform: translate(calc(-50% + 56px), -50%); }
+  to   { opacity: 1; transform: translate(-50%, -50%); }
+}
+@keyframes slideInFromBottom {
+  from { opacity: 0; transform: translate(-50%, calc(-50% + 56px)); }
+  to   { opacity: 1; transform: translate(-50%, -50%); }
+}
+@keyframes scaleIn {
+  from { opacity: 0; transform: translate(-50%, -50%) scale(0.8); }
+  to   { opacity: 1; transform: translate(-50%, -50%) scale(1); }
+}
+@keyframes travelDot {
+  from { stroke-dashoffset: 0; }
+  to   { stroke-dashoffset: -21; }
+}
+@keyframes nodeGlow {
+  0%, 100% { box-shadow: 0 0 6px hsl(var(--primary) / 0.6); }
+  50%       { box-shadow: 0 0 18px hsl(var(--primary) / 0.9); }
+}
+
+.animate-slide-from-left   { animation: slideInFromLeft   0.3s ease-out both; }
+.animate-slide-from-top    { animation: slideInFromTop    0.3s ease-out both; }
+.animate-slide-from-right  { animation: slideInFromRight  0.3s ease-out both; }
+.animate-slide-from-bottom { animation: slideInFromBottom 0.3s ease-out both; }
+.animate-scale-in          { animation: scaleIn           0.3s ease-out both; }
+.animate-node-glow         { animation: nodeGlow 1s ease-in-out infinite; }