Refactor approval handling and enhance markdown table styles

agent/core/agent_loop.py

@@ -169,6 +169,30 @@ def _is_transient_error(error: Exception) -> bool:
     return any(pattern in err_str for pattern in transient_patterns)
 
 
+def _friendly_error_message(error: Exception) -> str | None:
+    """Return a user-friendly message for known error types, or None to fall back to traceback."""
+    err_str = str(error).lower()
+
+    if "authentication" in err_str or "unauthorized" in err_str or "invalid x-api-key" in err_str:
+        return (
+            "Authentication failed — your API key is missing or invalid.\n\n"
+            "To fix this, set the API key for your model provider:\n"
+            "  • Anthropic:   export ANTHROPIC_API_KEY=sk-...\n"
+            "  • OpenAI:      export OPENAI_API_KEY=sk-...\n"
+            "  • HF Router:   export HF_TOKEN=hf_...\n\n"
+            "You can also add it to a .env file in the project root.\n"
+            "To switch models, use the /model command."
+        )
+
+    if "insufficient" in err_str and "credit" in err_str:
+        return (
+            "Insufficient API credits. Please check your account balance "
+            "at your model provider's dashboard."
+        )
+
+    return None
+
+
 async def _compact_and_notify(session: Session) -> None:
     """Run compaction and send event if context was reduced."""
     old_length = session.context_manager.context_length
@@ -559,7 +583,7 @@ class Handlers:
 
                 # If no tool calls, add assistant message and we're done
                 if not tool_calls:
-                    logger.warning(
+                    logger.debug(
                         "Agent loop ending: no tool calls. "
                         "finish_reason=%s, token_count=%d, "
                         "context_length=%d, max_context=%d, "
@@ -573,20 +597,6 @@ class Handlers:
                         max_iterations,
                         (content or "")[:500],
                     )
-                    await session.send_event(
-                        Event(
-                            event_type="tool_log",
-                            data={
-                                "tool": "system",
-                                "log": (
-                                    f"Loop exit: no tool calls. "
-                                    f"finish_reason={finish_reason}, "
-                                    f"tokens={token_count}/{session.context_manager.max_context}, "
-                                    f"iter={iteration}/{max_iterations}"
-                                ),
-                            },
-                        )
-                    )
                     if content:
                         assistant_msg = Message(role="assistant", content=content)
                         session.context_manager.add_message(assistant_msg, token_count)
@@ -802,10 +812,14 @@ class Handlers:
             except Exception as e:
                 import traceback
 
+                error_msg = _friendly_error_message(e)
+                if error_msg is None:
+                    error_msg = str(e) + "\n" + traceback.format_exc()
+
                 await session.send_event(
                     Event(
                         event_type="error",
-                        data={"error": str(e) + "\n" + traceback.format_exc()},
+                        data={"error": error_msg},
                     )
                 )
                 errored = True
@@ -1156,7 +1170,10 @@ async def submission_loop(
         async with tool_router:
             # Emit ready event after initialization
             await session.send_event(
-                Event(event_type="ready", data={"message": "Agent initialized"})
+                Event(event_type="ready", data={
+                    "message": "Agent initialized",
+                    "tool_count": len(tool_router.tools),
+                })
             )
 
             while session.is_running:

agent/main.py

@@ -251,7 +251,8 @@ async def event_listener(
             event = await event_queue.get()
 
             if event.event_type == "ready":
-                print_init_done()
+                tool_count = event.data.get("tool_count", 0) if event.data else 0
+                print_init_done(tool_count=tool_count)
                 ready_event.set()
             elif event.event_type == "assistant_message":
                 shimmer.stop()
@@ -711,8 +712,6 @@ async def main():
     # Clear screen
     os.system("clear" if os.name != "nt" else "cls")
 
-    print_banner()
-
     # Create prompt session for input (needed early for token prompt)
     prompt_session = PromptSession()
 
@@ -721,6 +720,16 @@ async def main():
     if not hf_token:
         hf_token = await _prompt_and_save_hf_token(prompt_session)
 
+    # Resolve username for banner
+    hf_user = None
+    try:
+        from huggingface_hub import HfApi
+        hf_user = HfApi(token=hf_token).whoami().get("name")
+    except Exception:
+        pass
+
+    print_banner(hf_user=hf_user)
+
     # Create queues for communication
     submission_queue = asyncio.Queue()
     event_queue = asyncio.Queue()

agent/utils/braille.py

@@ -0,0 +1,120 @@
+"""Braille-character canvas for high-resolution terminal graphics.
+
+Each terminal cell maps to a 2x4 dot grid using Unicode braille characters
+(U+2800–U+28FF), giving 2× horizontal and 4× vertical resolution.
+"""
+
+# Braille dot positions:  (0,0) (1,0)    dots 1,4
+#                         (0,1) (1,1)    dots 2,5
+#                         (0,2) (1,2)    dots 3,6
+#                         (0,3) (1,3)    dots 7,8
+_DOT_MAP = (
+    (0x01, 0x08),
+    (0x02, 0x10),
+    (0x04, 0x20),
+    (0x40, 0x80),
+)
+
+
+class BrailleCanvas:
+    """A pixel canvas that renders to braille characters."""
+
+    def __init__(self, term_width: int, term_height: int):
+        self.term_width = term_width
+        self.term_height = term_height
+        self.pixel_width = term_width * 2
+        self.pixel_height = term_height * 4
+        self._buf = bytearray(term_width * term_height)
+
+    def clear(self) -> None:
+        for i in range(len(self._buf)):
+            self._buf[i] = 0
+
+    def set_pixel(self, x: int, y: int) -> None:
+        if 0 <= x < self.pixel_width and 0 <= y < self.pixel_height:
+            cx, rx = divmod(x, 2)
+            cy, ry = divmod(y, 4)
+            self._buf[cy * self.term_width + cx] |= _DOT_MAP[ry][rx]
+
+    def render(self) -> list[str]:
+        lines = []
+        for row in range(self.term_height):
+            offset = row * self.term_width
+            line = "".join(
+                chr(0x2800 + self._buf[offset + col])
+                for col in range(self.term_width)
+            )
+            lines.append(line)
+        return lines
+
+
+# ── Bitmap font (5×7 uppercase + digits) ──────────────────────────────
+
+_FONT: dict[str, list[str]] = {}
+
+def _define_font() -> None:
+    """Define a simple 5×7 bitmap font for uppercase ASCII."""
+    glyphs = {
+        "A": [" ## ", "#  #", "#  #", "####", "#  #", "#  #", "#  #"],
+        "B": ["### ", "#  #", "#  #", "### ", "#  #", "#  #", "### "],
+        "C": [" ## ", "#  #", "#   ", "#   ", "#   ", "#  #", " ## "],
+        "D": ["### ", "#  #", "#  #", "#  #", "#  #", "#  #", "### "],
+        "E": ["####", "#   ", "#   ", "### ", "#   ", "#   ", "####"],
+        "F": ["####", "#   ", "#   ", "### ", "#   ", "#   ", "#   "],
+        "G": [" ## ", "#  #", "#   ", "# ##", "#  #", "#  #", " ###"],
+        "H": ["#  #", "#  #", "#  #", "####", "#  #", "#  #", "#  #"],
+        "I": ["###", " # ", " # ", " # ", " # ", " # ", "###"],
+        "J": ["  ##", "  # ", "  # ", "  # ", "  # ", "# # ", " #  "],
+        "K": ["#  #", "# # ", "##  ", "##  ", "# # ", "#  #", "#  #"],
+        "L": ["#   ", "#   ", "#   ", "#   ", "#   ", "#   ", "####"],
+        "M": ["#   #", "## ##", "# # #", "# # #", "#   #", "#   #", "#   #"],
+        "N": ["#  #", "## #", "## #", "# ##", "# ##", "#  #", "#  #"],
+        "O": [" ## ", "#  #", "#  #", "#  #", "#  #", "#  #", " ## "],
+        "P": ["### ", "#  #", "#  #", "### ", "#   ", "#   ", "#   "],
+        "Q": [" ## ", "#  #", "#  #", "#  #", "# ##", "#  #", " ## "],
+        "R": ["### ", "#  #", "#  #", "### ", "# # ", "#  #", "#  #"],
+        "S": [" ## ", "#  #", "#   ", " ## ", "   #", "#  #", " ## "],
+        "T": ["#####", "  #  ", "  #  ", "  #  ", "  #  ", "  #  ", "  #  "],
+        "U": ["#  #", "#  #", "#  #", "#  #", "#  #", "#  #", " ## "],
+        "V": ["#   #", "#   #", "#   #", " # # ", " # # ", "  #  ", "  #  "],
+        "W": ["#   #", "#   #", "#   #", "# # #", "# # #", "## ##", "#   #"],
+        "X": ["#  #", "#  #", " ## ", " ## ", " ## ", "#  #", "#  #"],
+        "Y": ["#   #", "#   #", " # # ", "  #  ", "  #  ", "  #  ", "  #  "],
+        "Z": ["####", "   #", "  # ", " #  ", "#   ", "#   ", "####"],
+        " ": ["  ", "  ", "  ", "  ", "  ", "  ", "  "],
+        "0": [" ## ", "#  #", "#  #", "#  #", "#  #", "#  #", " ## "],
+        "1": [" # ", "## ", " # ", " # ", " # ", " # ", "###"],
+        "2": [" ## ", "#  #", "   #", "  # ", " #  ", "#   ", "####"],
+        "3": [" ## ", "#  #", "   #", " ## ", "   #", "#  #", " ## "],
+        "4": ["#  #", "#  #", "#  #", "####", "   #", "   #", "   #"],
+        "5": ["####", "#   ", "### ", "   #", "   #", "#  #", " ## "],
+        "6": [" ## ", "#   ", "### ", "#  #", "#  #", "#  #", " ## "],
+        "7": ["####", "   #", "  # ", " #  ", " #  ", " #  ", " #  "],
+        "8": [" ## ", "#  #", "#  #", " ## ", "#  #", "#  #", " ## "],
+        "9": [" ## ", "#  #", "#  #", " ###", "   #", "   #", " ## "],
+    }
+    _FONT.update(glyphs)
+
+
+_define_font()
+
+
+def text_to_pixels(text: str, scale: int = 1) -> list[tuple[int, int]]:
+    """Convert text string to a list of (x, y) pixel positions using bitmap font."""
+    pixels = []
+    cursor_x = 0
+    for ch in text.upper():
+        glyph = _FONT.get(ch)
+        if glyph is None:
+            cursor_x += 4 * scale
+            continue
+        for row_idx, row in enumerate(glyph):
+            for col_idx, cell in enumerate(row):
+                if cell == "#":
+                    for sy in range(scale):
+                        for sx in range(scale):
+                            pixels.append((cursor_x + col_idx * scale + sx,
+                                           row_idx * scale + sy))
+        glyph_width = max(len(r) for r in glyph)
+        cursor_x += (glyph_width + 1) * scale
+    return pixels

agent/utils/terminal_display.py

@@ -8,7 +8,7 @@ from rich.panel import Panel
 from rich.theme import Theme
 
 _THEME = Theme({
-    "tool.name": "bold cyan",
+    "tool.name": "bold rgb(255,200,80)",
     "tool.args": "dim",
     "tool.ok": "dim green",
     "tool.fail": "dim red",
@@ -28,31 +28,75 @@ def get_console() -> Console:
 
 # ── Banner ─────────────────────────────────────────────────────────────
 
-def print_banner() -> None:
-    Y = "\033[38;2;255;200;50m"  # HF yellow
-    D = "\033[38;2;180;140;40m"  # dimmer gold for accents
-    R = "\033[0m"
-    art = f"""
-{_I}{Y} _  _                _             ___                _                _   {R}
-{_I}{Y}| || |_  _ __ _ __ _(_)_ _  __ _  | __|_ _ __ ___    /_\\  __ _ ___ _ _| |_ {R}
-{_I}{Y}| __ | || / _` / _` | | ' \\/ _` | | _/ _` / _/ -_)  / _ \\/ _` / -_) ' \\  _|{R}
-{_I}{Y}|_||_|\\_,_\\__, \\__, |_|_||_\\__, | |_|\\__,_\\__\\___| /_/ \\_\\__, \\___|_||_\\__|{R}
-{_I}{D}          |___/|___/       |___/                         |___/             {R}
-"""
-    _console.print(art, highlight=False)
-    _console.print(f"{_I}[dim]🤗 /help for commands · /quit to exit[/dim]\n")
+def print_banner(model: str | None = None, hf_user: str | None = None) -> None:
+    """Print particle logo then CRT boot sequence with system info."""
+    from agent.utils.particle_logo import run_particle_logo
+    from agent.utils.crt_boot import run_boot_sequence
+
+    # Particle coalesce logo — 1.5s converge, 2s hold
+    run_particle_logo(_console, hold_seconds=2.0)
+
+    # Clear screen for CRT boot — starts from top
+    _console.file.write("\033[2J\033[H")
+    _console.file.flush()
+
+    model_label = model or "anthropic/claude-opus-4-6"
+    user_label = hf_user or "not logged in"
+
+    # Warm gold palette matching the shimmer highlight (255, 200, 80)
+    gold = "rgb(255,200,80)"
+    dim_gold = "rgb(180,140,40)"
+
+    boot_lines = [
+        (f"{_I}Initializing agent runtime...", gold),
+        (f"{_I}  User: {user_label}", dim_gold),
+        (f"{_I}  Model: {model_label}", dim_gold),
+        (f"{_I}  Tools: loading...", dim_gold),
+        ("", ""),
+        (f"{_I}/help for commands · /model to switch · /quit to exit", gold),
+    ]
+
+    run_boot_sequence(_console, boot_lines)
 
 
 # ── Init progress ──────────────────────────────────────────────────────
 
-def print_init_done() -> None:
-    _console.print(f"{_I}[dim]Ready.[/dim]\n")
+def print_init_done(tool_count: int = 0) -> None:
+    import time
+    f = _console.file
+    # Overwrite the "Tools: loading..." line with actual count
+    f.write(f"\033[A\033[A\033[A\033[K")  # Move up 3 lines (blank + help + blank) then up to tools line
+    f.write(f"\033[A\033[K")
+    gold = "\033[38;2;180;140;40m"
+    reset = "\033[0m"
+    tool_text = f"{_I}  Tools: {tool_count} loaded"
+    for ch in tool_text:
+        f.write(f"{gold}{ch}{reset}")
+        f.flush()
+        time.sleep(0.012)
+    f.write("\n\n")
+    # Reprint the help line
+    f.write(f"{_I}\033[38;2;255;200;80m/help for commands · /model to switch · /quit to exit{reset}\n\n")
+    # Ready message — minimal padding
+    f.write(f"{_I}\033[38;2;255;200;80mReady. Let's build something impressive.{reset}\n")
+    f.flush()
 
 
 # ── Tool calls ─────────────────────────────────────────────────────────
 
 def print_tool_call(tool_name: str, args_preview: str) -> None:
-    _console.print(f"{_I}[tool.name]▸ {tool_name}[/tool.name]  [tool.args]{args_preview}[/tool.args]")
+    import time
+    f = _console.file
+    # CRT-style: type out tool name in HF yellow
+    gold = "\033[38;2;255;200;80m"
+    reset = "\033[0m"
+    f.write(f"{_I}{gold}▸ ")
+    for ch in tool_name:
+        f.write(ch)
+        f.flush()
+        time.sleep(0.015)
+    f.write(f"{reset}  \033[2m{args_preview}{reset}\n")
+    f.flush()
 
 
 def print_tool_output(output: str, success: bool, truncate: bool = True) -> None:
@@ -146,7 +190,7 @@ class SubAgentDisplay:
         lines = []
         # Header: ▸ research (stats)
         stats = self._format_stats()
-        header = f"{_I}\033[1;36m▸ research\033[0m"
+        header = f"{_I}\033[38;2;255;200;80m▸ research\033[0m"
         if stats:
             header += f"  \033[2m({stats})\033[0m"
         lines.append(header)
@@ -183,9 +227,37 @@ def print_tool_log(tool: str, log: str) -> None:
 # ── Messages ───────────────────────────────────────────────────────────
 
 def print_markdown(text: str) -> None:
+    import io, time, random
     from rich.padding import Padding
+
     _console.print()
-    _console.print(Padding(Markdown(text), (0, 0, 0, 2)))
+
+    # Render markdown to a string buffer so we can type it out
+    buf = io.StringIO()
+    buf_console = Console(file=buf, width=_console.width, highlight=False, theme=_THEME)
+    buf_console.print(Padding(Markdown(text), (0, 0, 0, 2)))
+    rendered = buf.getvalue()
+
+    # Strip trailing whitespace from each line so we don't type across the full width
+    lines = rendered.split("\n")
+    rendered = "\n".join(line.rstrip() for line in lines)
+
+    # CRT typewriter effect — fast, with occasional glitch
+    rng = random.Random(42)
+    f = _console.file
+    for ch in rendered:
+        f.write(ch)
+        f.flush()
+        if ch == "\n":
+            time.sleep(0.002)
+        elif ch == " ":
+            time.sleep(0.002)
+        elif rng.random() < 0.03:
+            time.sleep(0.015)
+        else:
+            time.sleep(0.004)
+    f.write("\n")
+    f.flush()
 
 
 def print_error(message: str) -> None:

pyproject.toml

@@ -5,15 +5,11 @@ description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
+    # Core dependencies
     "datasets>=4.4.1",
-    # Core dependencies (always required)
     "pydantic>=2.12.3",
     "python-dotenv>=1.2.1",
-]
-
-[project.optional-dependencies]
-# Agent runtime dependencies
-agent = [
+    # Agent runtime dependencies
     "requests>=2.33.0",
     "litellm>=1.83.0",
     "huggingface-hub>=1.0.1",
@@ -23,7 +19,6 @@ agent = [
     "rich>=13.0.0",
     "nbconvert>=7.16.6",
     "nbformat>=5.10.4",
-    "datasets>=4.3.0",  # For session logging to HF datasets
     "whoosh>=2.7.4",
     # Web backend dependencies
     "fastapi>=0.115.0",
@@ -32,6 +27,8 @@ agent = [
     "websockets>=13.0",
 ]
 
+[project.optional-dependencies]
+
 # Evaluation/benchmarking dependencies
 eval = [
     "inspect-ai>=0.3.149",
@@ -45,9 +42,9 @@ dev = [
     "pytest>=9.0.2",
 ]
 
-# All dependencies (agent + eval + dev)
+# All dependencies (eval + dev)
 all = [
-    "hf-agent[agent,eval,dev]",
+    "hf-agent[eval,dev]",
 ]
 
 [build-system]

uv.lock

@@ -997,13 +997,6 @@ name = "hf-agent"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
-    { name = "datasets" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-]
-
-[package.optional-dependencies]
-agent = [
     { name = "datasets" },
     { name = "fastapi" },
     { name = "fastmcp" },
@@ -1013,6 +1006,8 @@ agent = [
     { name = "nbconvert" },
     { name = "nbformat" },
     { name = "prompt-toolkit" },
+    { name = "pydantic" },
+    { name = "python-dotenv" },
     { name = "requests" },
     { name = "rich" },
     { name = "thefuzz" },
@@ -1020,26 +1015,14 @@ agent = [
     { name = "websockets" },
     { name = "whoosh" },
 ]
+
+[package.optional-dependencies]
 all = [
     { name = "datasets" },
-    { name = "fastapi" },
-    { name = "fastmcp" },
-    { name = "httpx" },
-    { name = "huggingface-hub" },
     { name = "inspect-ai" },
-    { name = "litellm" },
-    { name = "nbconvert" },
-    { name = "nbformat" },
     { name = "pandas" },
-    { name = "prompt-toolkit" },
     { name = "pytest" },
-    { name = "requests" },
-    { name = "rich" },
     { name = "tenacity" },
-    { name = "thefuzz" },
-    { name = "uvicorn", extra = ["standard"] },
-    { name = "websockets" },
-    { name = "whoosh" },
 ]
 dev = [
     { name = "pytest" },
@@ -1054,31 +1037,30 @@ eval = [
 [package.metadata]
 requires-dist = [
     { name = "datasets", specifier = ">=4.4.1" },
-    { name = "datasets", marker = "extra == 'agent'", specifier = ">=4.3.0" },
     { name = "datasets", marker = "extra == 'eval'", specifier = ">=4.3.0" },
-    { name = "fastapi", marker = "extra == 'agent'", specifier = ">=0.115.0" },
-    { name = "fastmcp", marker = "extra == 'agent'", specifier = ">=3.2.0" },
-    { name = "hf-agent", extras = ["agent", "eval", "dev"], marker = "extra == 'all'" },
-    { name = "httpx", marker = "extra == 'agent'", specifier = ">=0.27.0" },
-    { name = "huggingface-hub", marker = "extra == 'agent'", specifier = ">=1.0.1" },
+    { name = "fastapi", specifier = ">=0.115.0" },
+    { name = "fastmcp", specifier = ">=3.2.0" },
+    { name = "hf-agent", extras = ["eval", "dev"], marker = "extra == 'all'" },
+    { name = "httpx", specifier = ">=0.27.0" },
+    { name = "huggingface-hub", specifier = ">=1.0.1" },
     { name = "inspect-ai", marker = "extra == 'eval'", specifier = ">=0.3.149" },
-    { name = "litellm", marker = "extra == 'agent'", specifier = ">=1.83.0" },
-    { name = "nbconvert", marker = "extra == 'agent'", specifier = ">=7.16.6" },
-    { name = "nbformat", marker = "extra == 'agent'", specifier = ">=5.10.4" },
+    { name = "litellm", specifier = ">=1.83.0" },
+    { name = "nbconvert", specifier = ">=7.16.6" },
+    { name = "nbformat", specifier = ">=5.10.4" },
     { name = "pandas", marker = "extra == 'eval'", specifier = ">=2.3.3" },
-    { name = "prompt-toolkit", marker = "extra == 'agent'", specifier = ">=3.0.0" },
+    { name = "prompt-toolkit", specifier = ">=3.0.0" },
     { name = "pydantic", specifier = ">=2.12.3" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=9.0.2" },
     { name = "python-dotenv", specifier = ">=1.2.1" },
-    { name = "requests", marker = "extra == 'agent'", specifier = ">=2.33.0" },
-    { name = "rich", marker = "extra == 'agent'", specifier = ">=13.0.0" },
+    { name = "requests", specifier = ">=2.33.0" },
+    { name = "rich", specifier = ">=13.0.0" },
     { name = "tenacity", marker = "extra == 'eval'", specifier = ">=8.0.0" },
-    { name = "thefuzz", marker = "extra == 'agent'", specifier = ">=0.22.1" },
-    { name = "uvicorn", extras = ["standard"], marker = "extra == 'agent'", specifier = ">=0.32.0" },
-    { name = "websockets", marker = "extra == 'agent'", specifier = ">=13.0" },
-    { name = "whoosh", marker = "extra == 'agent'", specifier = ">=2.7.4" },
+    { name = "thefuzz", specifier = ">=0.22.1" },
+    { name = "uvicorn", extras = ["standard"], specifier = ">=0.32.0" },
+    { name = "websockets", specifier = ">=13.0" },
+    { name = "whoosh", specifier = ">=2.7.4" },
 ]
-provides-extras = ["agent", "eval", "dev", "all"]
+provides-extras = ["eval", "dev", "all"]
 
 [[package]]
 name = "hf-xet"