@drico2008/fincli 0.1.3 → 0.1.9

package/fincli/app/modules/session_history.py

@@ -0,0 +1,113 @@
+"""Session history service for FinCLI commands."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import re
+from uuid import uuid4
+
+from fincli.app.storage.database import FinCLIDatabase
+
+
+_AI_NEWS_KEY_PATTERN = re.compile(r"^/(ai_model|news_model)\s+key\s+(\S+)\s+(.+)$", re.IGNORECASE)
+_PROVIDER_KEY_PATTERN = re.compile(r"^/provider\s+key\s+(\S+)\s+(.+)$", re.IGNORECASE)
+_SECRET_VALUE_PATTERNS = (
+    re.compile(r"(?i)(api[_ -]?key|token|secret|password)\s*[:=]\s*\S+"),
+)
+
+
+class SessionHistoryService:
+    """Persist local command sessions and sanitized command events."""
+
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def start_session(self, title: str = "FinCLI session") -> str:
+        session_id = uuid4().hex[:12]
+        now = _now()
+        self.db.execute(
+            "INSERT INTO sessions (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)",
+            (session_id, title, now, now),
+        )
+        return session_id
+
+    def save_session(self, session_id: str, title: str) -> None:
+        self.db.execute(
+            "UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?",
+            (title.strip() or "FinCLI session", _now(), session_id),
+        )
+
+    def record_event(self, session_id: str, command: str, status: str, output_preview: str = "") -> None:
+        sanitized_command = sanitize_history_text(command.strip())
+        sanitized_output = sanitize_history_text(output_preview.strip())[:1200]
+        if not sanitized_command:
+            return
+        self.db.execute(
+            """
+            INSERT INTO session_events (session_id, command, status, output_preview, created_at)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (session_id, sanitized_command, status, sanitized_output, _now()),
+        )
+        self.db.execute("UPDATE sessions SET updated_at = ? WHERE id = ?", (_now(), session_id))
+
+    def list_sessions(self, limit: int = 20) -> list[dict[str, object]]:
+        rows = self.db.query(
+            """
+            SELECT s.id, s.title, s.created_at, s.updated_at, COUNT(e.id) AS event_count
+            FROM sessions s
+            LEFT JOIN session_events e ON e.session_id = s.id
+            GROUP BY s.id
+            ORDER BY s.updated_at DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+        return [dict(row) for row in rows]
+
+    def get_events(self, session_id: str, limit: int = 100) -> list[dict[str, object]]:
+        rows = self.db.query(
+            """
+            SELECT id, command, status, output_preview, created_at
+            FROM session_events
+            WHERE session_id = ?
+            ORDER BY id ASC
+            LIMIT ?
+            """,
+            (session_id, limit),
+        )
+        return [dict(row) for row in rows]
+
+    def get_session(self, session_id: str) -> dict[str, object] | None:
+        rows = self.db.query("SELECT id, title, created_at, updated_at FROM sessions WHERE id = ?", (session_id,))
+        return dict(rows[0]) if rows else None
+
+    def delete_session(self, session_id: str) -> int:
+        self.db.execute("DELETE FROM session_events WHERE session_id = ?", (session_id,))
+        self.db.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+        return 1
+
+    def clear_events(self, session_id: str) -> None:
+        self.db.execute("DELETE FROM session_events WHERE session_id = ?", (session_id,))
+        self.db.execute("UPDATE sessions SET updated_at = ? WHERE id = ?", (_now(), session_id))
+
+    def clear_all(self) -> None:
+        self.db.execute("DELETE FROM session_events")
+        self.db.execute("DELETE FROM sessions")
+
+
+def sanitize_history_text(value: str) -> str:
+    sanitized = value
+    match = _AI_NEWS_KEY_PATTERN.match(sanitized)
+    if match:
+        return f"/{match.group(1)} key {match.group(2)} <redacted>"
+    match = _PROVIDER_KEY_PATTERN.match(sanitized)
+    if match:
+        return f"/provider key {match.group(1)} <redacted>"
+    for pattern in _SECRET_VALUE_PATTERNS:
+        sanitized = pattern.sub(lambda match: f"{match.group(1)}=<redacted>", sanitized)
+    return sanitized
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")

package/fincli/app/providers/ai/anthropic_provider.py

@@ -1,11 +1,12 @@
-"""Anthropic provider placeholder for Phase 2."""
+"""Anthropic provider compatibility wrapper."""
 
-from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
-from fincli.app.utils.errors import ProviderError
+from __future__ import annotations
 
+import os
 
-class AnthropicProvider(BaseAIProvider):
-    name = "anthropic"
+from fincli.app.providers.ai.http_provider import AnthropicProviderHTTP
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("Anthropic client belum diimplementasi di Phase 1.")
+
+class AnthropicProvider(AnthropicProviderHTTP):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__(api_key or os.getenv("ANTHROPIC_API_KEY"))

package/fincli/app/providers/ai/gemini_provider.py

@@ -1,11 +1,12 @@
-"""Gemini provider placeholder for Phase 2."""
+"""Gemini provider compatibility wrapper."""
 
-from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
-from fincli.app.utils.errors import ProviderError
+from __future__ import annotations
 
+import os
 
-class GeminiProvider(BaseAIProvider):
-    name = "gemini"
+from fincli.app.providers.ai.http_provider import GeminiProviderHTTP
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("Gemini client belum diimplementasi di Phase 1.")
+
+class GeminiProvider(GeminiProviderHTTP):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__(api_key or os.getenv("GEMINI_API_KEY"))

package/fincli/app/providers/ai/groq_provider.py

@@ -1,11 +1,12 @@
-"""Groq provider placeholder for Phase 2."""
+"""Groq provider compatibility wrapper."""
 
-from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
-from fincli.app.utils.errors import ProviderError
+from __future__ import annotations
 
+import os
 
-class GroqProvider(BaseAIProvider):
-    name = "groq"
+from fincli.app.providers.ai.http_provider import OpenAICompatibleProvider
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("Groq client belum diimplementasi di Phase 1.")
+
+class GroqProvider(OpenAICompatibleProvider):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__("groq", "https://api.groq.com/openai/v1", api_key or os.getenv("GROQ_API_KEY"))

package/fincli/app/providers/ai/huggingface_provider.py

@@ -1,11 +1,12 @@
-"""HuggingFace provider placeholder for Phase 2."""
+"""HuggingFace provider compatibility wrapper."""
 
-from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
-from fincli.app.utils.errors import ProviderError
+from __future__ import annotations
 
+import os
 
-class HuggingFaceProvider(BaseAIProvider):
-    name = "huggingface"
+from fincli.app.providers.ai.http_provider import OpenAICompatibleProvider
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("HuggingFace client belum diimplementasi di Phase 1.")
+
+class HuggingFaceProvider(OpenAICompatibleProvider):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__("huggingface", "https://router.huggingface.co/v1", api_key or os.getenv("HUGGINGFACE_API_KEY"))

package/fincli/app/providers/ai/openai_provider.py

@@ -1,11 +1,12 @@
-"""OpenAI provider placeholder for Phase 2."""
+"""OpenAI provider compatibility wrapper."""
 
-from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
-from fincli.app.utils.errors import ProviderError
+from __future__ import annotations
 
+import os
 
-class OpenAIProvider(BaseAIProvider):
-    name = "openai"
+from fincli.app.providers.ai.http_provider import OpenAICompatibleProvider
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("OpenAI client belum diimplementasi di Phase 1.")
+
+class OpenAIProvider(OpenAICompatibleProvider):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__("openai", "https://api.openai.com/v1", api_key or os.getenv("OPENAI_API_KEY"))

package/fincli/app/providers/ai/openrouter_provider.py

@@ -1,11 +1,12 @@
-"""OpenRouter provider placeholder for Phase 2."""
+"""OpenRouter provider compatibility wrapper."""
 
-from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
-from fincli.app.utils.errors import ProviderError
+from __future__ import annotations
 
+import os
 
-class OpenRouterProvider(BaseAIProvider):
-    name = "openrouter"
+from fincli.app.providers.ai.http_provider import OpenAICompatibleProvider
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("OpenRouter client belum diimplementasi di Phase 1.")
+
+class OpenRouterProvider(OpenAICompatibleProvider):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__("openrouter", "https://openrouter.ai/api/v1", api_key or os.getenv("OPENROUTER_API_KEY"))

package/fincli/app/providers/ai/together_provider.py

@@ -1,11 +1,12 @@
-"""Together AI provider placeholder for Phase 2."""
+"""Together AI provider compatibility wrapper."""
 
-from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
-from fincli.app.utils.errors import ProviderError
+from __future__ import annotations
 
+import os
 
-class TogetherProvider(BaseAIProvider):
-    name = "together"
+from fincli.app.providers.ai.http_provider import OpenAICompatibleProvider
 
-    async def complete(self, request: AIRequest) -> AIResponse:
-        raise ProviderError("Together AI client belum diimplementasi di Phase 1.")
+
+class TogetherProvider(OpenAICompatibleProvider):
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__("together", "https://api.together.xyz/v1", api_key or os.getenv("TOGETHER_API_KEY"))

package/fincli/app/providers/market/manager.py

@@ -32,7 +32,7 @@ MARKET_PROVIDERS: dict[str, MarketProviderInfo] = {
         name="custom",
         realtime=True,
         status="configured",
-        notes="Custom API provider scaffold. Requires MARKET_DATA_API_KEY.",
+        notes="Custom REST API provider. Requires MARKET_DATA_API_KEY and MARKET_DATA_BASE_URL.",
     ),
     "finnhub": MarketProviderInfo(
         name="finnhub",

package/fincli/app/providers/market/news_provider.py

@@ -1,4 +1,4 @@
-"""News provider placeholder for Phase 2."""
+"""Base news-only provider adapter."""
 
 from fincli.app.providers.market.base import BaseMarketProvider, Candle, FundamentalSnapshot, NewsItem, ProviderStatus, Quote
 from fincli.app.utils.errors import ProviderError
@@ -14,7 +14,7 @@ class NewsProvider(BaseMarketProvider):
         raise ProviderError("News provider tidak menyediakan OHLCV.")
 
     async def news(self, symbol: str, limit: int = 5) -> list[NewsItem]:
-        raise ProviderError("News fetching belum diimplementasi di Phase 2.")
+        raise ProviderError("News provider belum dikonfigurasi untuk mengambil berita.", "Gunakan /news_model untuk memilih provider market/news aktif.")
 
     async def fundamentals(self, symbol: str) -> FundamentalSnapshot:
         raise ProviderError("News provider tidak menyediakan fundamental.")
@@ -23,6 +23,6 @@ class NewsProvider(BaseMarketProvider):
         return ProviderStatus(
             name=self.name,
             realtime=False,
-            status="configured",
-            message="News fetching pending in Phase 2.",
+            status="unavailable",
+            message="News-only adapter belum memiliki source aktif. Gunakan /news_model untuk provider aktual.",
         )

package/fincli/app/providers/market/yfinance_provider.py

@@ -1,4 +1,4 @@
-"""yfinance fallback provider placeholder for Phase 2."""
+"""yfinance fallback provider for delayed public market data."""
 
 import asyncio
 from dataclasses import dataclass

package/fincli/app/services/web_research.py

@@ -0,0 +1,267 @@
+"""Lightweight web research service for AI assistance."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from html import unescape
+from html.parser import HTMLParser
+import re
+from urllib.parse import parse_qs, quote_plus, unquote, urlparse
+from xml.etree import ElementTree
+
+import httpx
+
+from fincli.app.utils.errors import ProviderError
+
+
+@dataclass(frozen=True, slots=True)
+class WebSearchResult:
+    title: str
+    url: str
+    snippet: str = ""
+    content: str = ""
+
+
+class WebResearchService:
+    """Search and fetch public web pages without browser automation."""
+
+    def __init__(self, client: httpx.AsyncClient | None = None, timeout_seconds: float = 6.0) -> None:
+        self._client = client
+        self.timeout_seconds = timeout_seconds
+
+    async def research(self, query: str, limit: int = 3) -> list[WebSearchResult]:
+        normalized = query.strip()
+        if not normalized:
+            return []
+        search_results = await self.search(normalized, limit=limit)
+        enriched: list[WebSearchResult] = []
+        for result in search_results[:limit]:
+            content = await self.fetch_text(result.url)
+            enriched.append(
+                WebSearchResult(
+                    title=result.title,
+                    url=result.url,
+                    snippet=result.snippet,
+                    content=content,
+                )
+            )
+        return enriched
+
+    async def search(self, query: str, limit: int = 5) -> list[WebSearchResult]:
+        errors: list[str] = []
+        for searcher in (self._search_duckduckgo, self._search_google_news):
+            try:
+                results = await searcher(query, limit)
+            except ProviderError as exc:
+                errors.append(str(exc))
+                continue
+            if results:
+                return results
+        detail = "\n".join(f"- {error}" for error in errors) if errors else "Tidak ada hasil publik."
+        raise ProviderError(
+            "Semua web search provider gagal atau kosong.",
+            f"{detail}\nCoba ulangi, sederhanakan query, atau cek koneksi/DNS.",
+        )
+
+    async def _search_duckduckgo(self, query: str, limit: int) -> list[WebSearchResult]:
+        html = await self._get_text(f"https://duckduckgo.com/html/?q={quote_plus(query)}")
+        parser = _DuckDuckGoParser()
+        parser.feed(html)
+        results: list[WebSearchResult] = []
+        seen: set[str] = set()
+        for item in parser.results:
+            target = _clean_duckduckgo_url(item.url)
+            if not target or target in seen:
+                continue
+            seen.add(target)
+            results.append(WebSearchResult(title=_clean_text(item.title), url=target, snippet=_clean_text(item.snippet)))
+            if len(results) >= limit:
+                break
+        return results
+
+    async def _search_google_news(self, query: str, limit: int) -> list[WebSearchResult]:
+        rss = await self._get_text(f"https://news.google.com/rss/search?q={quote_plus(query)}&hl=id&gl=ID&ceid=ID:id")
+        try:
+            root = ElementTree.fromstring(rss)
+        except ElementTree.ParseError as exc:
+            raise ProviderError("Google News RSS tidak valid.") from exc
+
+        results: list[WebSearchResult] = []
+        seen: set[str] = set()
+        for item in root.findall(".//item"):
+            title = _clean_text(item.findtext("title") or "")
+            url = _clean_text(item.findtext("link") or "")
+            snippet = _clean_text(_html_to_text(item.findtext("description") or ""))
+            if not title or not url or url in seen:
+                continue
+            seen.add(url)
+            results.append(WebSearchResult(title=title, url=url, snippet=snippet))
+            if len(results) >= limit:
+                break
+        return results
+
+    async def fetch_text(self, url: str, max_chars: int = 2400) -> str:
+        if not url.startswith(("http://", "https://")):
+            return ""
+        try:
+            html = await self._get_text(url)
+        except ProviderError:
+            return ""
+        text = _html_to_text(html)
+        return text[:max_chars]
+
+    async def _get_text(self, url: str) -> str:
+        headers = {
+            "User-Agent": "FinCLI/0.1 web research (+https://www.npmjs.com/package/@drico2008/fincli)",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7",
+        }
+        close_client = self._client is None
+        client = self._client or httpx.AsyncClient(timeout=self.timeout_seconds, follow_redirects=True, headers=headers)
+        try:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            return response.text
+        except httpx.TimeoutException as exc:
+            raise ProviderError("Web research timeout.", f"URL: {url}") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"Web research gagal: HTTP {exc.response.status_code}.", f"URL: {url}") from exc
+        except httpx.RequestError as exc:
+            raise ProviderError(f"Web research gagal terhubung: {exc}.", f"URL: {url}") from exc
+        finally:
+            if close_client:
+                await client.aclose()
+
+
+def should_use_web_research(prompt: str) -> bool:
+    """Detect prompts that benefit from current public web context."""
+    normalized = prompt.lower()
+    keywords = (
+        "terkini",
+        "terbaru",
+        "hari ini",
+        "sekarang",
+        "saat ini",
+        "update",
+        "berita",
+        "news",
+        "web",
+        "search",
+        "cari",
+        "penyebab",
+        "mengapa",
+        "kenapa",
+        "rupiah",
+        "inflasi",
+        "suku bunga",
+        "bank indonesia",
+        "fed",
+        "dollar",
+        "dolar",
+        "yield",
+        "minyak",
+        "emas",
+    )
+    return any(keyword in normalized for keyword in keywords)
+
+
+def build_web_research_context(results: list[WebSearchResult]) -> str:
+    if not results:
+        return "Web Research: no public web context returned."
+    sections = ["Web Research Context:"]
+    for index, result in enumerate(results, start=1):
+        sections.extend(
+            [
+                f"{index}. {result.title}",
+                f"URL: {result.url}",
+                f"Snippet: {result.snippet or 'N/A'}",
+                f"Extract: {result.content or 'N/A'}",
+            ]
+        )
+    return "\n".join(sections)
+
+
+class _DuckResult:
+    def __init__(self) -> None:
+        self.title = ""
+        self.url = ""
+        self.snippet = ""
+
+
+class _DuckDuckGoParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.results: list[_DuckResult] = []
+        self._current: _DuckResult | None = None
+        self._capture: str | None = None
+        self._buffer: list[str] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attr = dict(attrs)
+        classes = attr.get("class", "")
+        if tag == "a" and "result__a" in classes:
+            self._current = _DuckResult()
+            self._current.url = attr.get("href", "") or ""
+            self._capture = "title"
+            self._buffer = []
+        elif self._current is not None and tag in {"a", "div"} and "result__snippet" in classes:
+            self._capture = "snippet"
+            self._buffer = []
+
+    def handle_data(self, data: str) -> None:
+        if self._capture:
+            self._buffer.append(data)
+
+    def handle_endtag(self, tag: str) -> None:
+        if self._current is None or self._capture is None:
+            return
+        if self._capture == "title" and tag == "a":
+            self._current.title = _clean_text(" ".join(self._buffer))
+            self._capture = None
+            self._buffer = []
+        elif self._capture == "snippet" and tag in {"a", "div"}:
+            self._current.snippet = _clean_text(" ".join(self._buffer))
+            self.results.append(self._current)
+            self._current = None
+            self._capture = None
+            self._buffer = []
+
+
+class _TextExtractor(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.parts: list[str] = []
+        self._skip_depth = 0
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag in {"script", "style", "noscript", "svg"}:
+            self._skip_depth += 1
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in {"script", "style", "noscript", "svg"} and self._skip_depth:
+            self._skip_depth -= 1
+
+    def handle_data(self, data: str) -> None:
+        if not self._skip_depth:
+            cleaned = _clean_text(data)
+            if cleaned:
+                self.parts.append(cleaned)
+
+
+def _html_to_text(html: str) -> str:
+    extractor = _TextExtractor()
+    extractor.feed(html)
+    return _clean_text(" ".join(extractor.parts))
+
+
+def _clean_text(value: str) -> str:
+    text = unescape(value)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def _clean_duckduckgo_url(url: str) -> str:
+    parsed = urlparse(url)
+    if parsed.netloc.endswith("duckduckgo.com") and parsed.path.startswith("/l/"):
+        target = parse_qs(parsed.query).get("uddg", [""])[0]
+        return unquote(target)
+    return url

package/fincli/app/storage/cache.py

@@ -1,4 +1,4 @@
-"""Lightweight in-memory cache scaffold for provider responses."""
+"""Lightweight in-memory TTL cache for provider responses."""
 
 from __future__ import annotations
 
@@ -16,7 +16,7 @@ class CacheEntry(Generic[T]):
 
 
 class TTLCache(Generic[T]):
-    """Simple TTL cache for Phase 1. Provider modules can replace this later."""
+    """Simple runtime TTL cache used by router and provider workflows."""
 
     def __init__(self, default_ttl: int = 300) -> None:
         self.default_ttl = default_ttl

package/fincli/app/storage/database.py

@@ -80,6 +80,23 @@ class FinCLIDatabase:
                             created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                             PRIMARY KEY (namespace, cache_key)
                         );
+
+                        CREATE TABLE IF NOT EXISTS sessions (
+                            id TEXT PRIMARY KEY,
+                            title TEXT NOT NULL,
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS session_events (
+                            id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            session_id TEXT NOT NULL,
+                            command TEXT NOT NULL,
+                            status TEXT NOT NULL,
+                            output_preview TEXT DEFAULT '',
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+                        );
                         """
                     )
         except sqlite3.Error as exc:

package/fincli/app/storage/secrets.py

@@ -24,7 +24,7 @@ def load_local_secrets(path: Path | None = None, *, override: bool = False) -> N
         key, value = stripped.split("=", 1)
         key = key.strip()
         value = _unquote(value.strip())
-        if key and (override or key not in os.environ):
+        if key and (override or key not in os.environ or os.environ.get(key, "") == ""):
             os.environ[key] = value
 
 
@@ -72,8 +72,11 @@ def read_secrets(path: Path | None = None) -> dict[str, str]:
 def secret_source(env_key: str, path: Path | None = None) -> str:
     """Return a display-safe source for a secret."""
     path = path or SECRETS_FILE
+    current = os.getenv(env_key)
+    if not current:
+        return "-"
     if env_key in os.environ:
-        if env_key in read_secrets(path):
+        if read_secrets(path).get(env_key) == current:
             return "~/.fincli/secrets.env"
         return "environment/.env"
     return "-"

package/fincli/app/tui/components.py

@@ -52,4 +52,4 @@ def format_thinking_message(message: str) -> Text:
 
 
 def format_ai_message(message: str) -> Markdown:
-    return Markdown(f"* {message}")
+    return Markdown(message)