@drico2008/fincli 0.1.2 → 0.1.9

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/custom_provider.py

@@ -119,12 +119,12 @@ class CustomMarketProvider(BaseMarketProvider):
         if not self.api_key:
             raise ProviderError(
                 "API key custom market provider belum diatur.",
-                "Isi MARKET_DATA_API_KEY di .env.",
+                "Gunakan /news_model key custom <api_key> <base_url>.",
             )
         if not self.base_url:
             raise ProviderError(
                 "Base URL custom market provider belum diatur.",
-                "Isi MARKET_DATA_BASE_URL di .env.",
+                "Gunakan /news_model key custom <api_key> <base_url>.",
             )
 
         close_client = self._client is None

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

@@ -141,7 +141,7 @@ class FinnhubProvider:
 
     async def _get(self, path: str, params: dict[str, object]) -> Any:
         if not self.api_key:
-            raise ProviderError("API key Finnhub belum diatur.", "Isi FINNHUB_API_KEY di .env.")
+            raise ProviderError("API key Finnhub belum diatur.", "Gunakan /news_model key finnhub <api_key>.")
         close_client = self._client is None
         client = self._client or httpx.AsyncClient(timeout=30)
         query = {**params, "token": self.api_key}

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

@@ -10,6 +10,7 @@ from fincli.app.providers.market.custom_provider import CustomMarketProvider
 from fincli.app.providers.market.finnhub_provider import FinnhubProvider
 from fincli.app.providers.market.twelvedata_provider import TwelveDataProvider
 from fincli.app.providers.market.yfinance_provider import YFinanceProvider
+from fincli.app.storage.secrets import secret_source
 
 
 @dataclass(frozen=True, slots=True)
@@ -31,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",
@@ -92,25 +93,25 @@ class MarketProviderManager:
                 "provider": "custom",
                 "key": "MARKET_DATA_API_KEY",
                 "status": _mask_status(os.getenv("MARKET_DATA_API_KEY")),
-                "source": ".env" if os.getenv("MARKET_DATA_API_KEY") else "-",
+                "source": secret_source("MARKET_DATA_API_KEY"),
             },
             {
                 "provider": "custom",
                 "key": "MARKET_DATA_BASE_URL",
                 "status": _mask_status(os.getenv("MARKET_DATA_BASE_URL")),
-                "source": ".env" if os.getenv("MARKET_DATA_BASE_URL") else "-",
+                "source": secret_source("MARKET_DATA_BASE_URL"),
             },
             {
                 "provider": "finnhub",
                 "key": "FINNHUB_API_KEY",
                 "status": _mask_status(os.getenv("FINNHUB_API_KEY")),
-                "source": ".env" if os.getenv("FINNHUB_API_KEY") else "-",
+                "source": secret_source("FINNHUB_API_KEY"),
             },
             {
                 "provider": "twelvedata",
                 "key": "TWELVE_DATA_API_KEY",
                 "status": _mask_status(os.getenv("TWELVE_DATA_API_KEY")),
-                "source": ".env" if os.getenv("TWELVE_DATA_API_KEY") else "-",
+                "source": secret_source("TWELVE_DATA_API_KEY"),
             },
         ]
 

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/twelvedata_provider.py

@@ -76,7 +76,7 @@ class TwelveDataProvider:
 
     async def _get(self, path: str, params: dict[str, object]) -> Any:
         if not self.api_key:
-            raise ProviderError("API key Twelve Data belum diatur.", "Isi TWELVE_DATA_API_KEY di .env.")
+            raise ProviderError("API key Twelve Data belum diatur.", "Gunakan /news_model key twelvedata <api_key>.")
         close_client = self._client is None
         client = self._client or httpx.AsyncClient(timeout=30)
         try:

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/config.py

@@ -19,10 +19,8 @@ except ImportError:  # pragma: no cover - dependency exists in normal install
 
 from fincli.app.utils.errors import ConfigError
 from fincli.app.utils.formatting import mask_secret
-
-
-APP_DIR = Path.home() / ".fincli"
-CONFIG_FILE = APP_DIR / "config.json"
+from fincli.app.storage.config_paths import APP_DIR, CONFIG_FILE
+from fincli.app.storage.secrets import load_local_secrets
 
 
 @dataclass(slots=True)
@@ -66,6 +64,7 @@ class ConfigManager:
     def load(self) -> FinCLISettings:
         if load_dotenv is not None:
             load_dotenv()
+        load_local_secrets()
 
         if not self.config_file.exists():
             return FinCLISettings()

package/fincli/app/storage/config_paths.py

@@ -0,0 +1,9 @@
+"""Shared local storage paths."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+APP_DIR = Path.home() / ".fincli"
+CONFIG_FILE = APP_DIR / "config.json"

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

@@ -0,0 +1,104 @@
+"""Local secret storage for globally installed FinCLI."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from fincli.app.storage.config_paths import APP_DIR
+from fincli.app.utils.errors import ConfigError
+
+
+SECRETS_FILE = APP_DIR / "secrets.env"
+
+
+def load_local_secrets(path: Path | None = None, *, override: bool = False) -> None:
+    """Load persisted secrets into process environment."""
+    path = path or SECRETS_FILE
+    if not path.exists():
+        return
+    for line in path.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, value = stripped.split("=", 1)
+        key = key.strip()
+        value = _unquote(value.strip())
+        if key and (override or key not in os.environ or os.environ.get(key, "") == ""):
+            os.environ[key] = value
+
+
+def save_secret(env_key: str, value: str, path: Path | None = None) -> None:
+    """Persist a secret locally and expose it to the current process."""
+    path = path or SECRETS_FILE
+    key = _validate_env_key(env_key)
+    secret = _sanitize_value(value)
+    if not secret:
+        raise ConfigError(f"Nilai {key} kosong.")
+
+    secrets = read_secrets(path)
+    secrets[key] = secret
+
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        lines = ["# FinCLI local secrets. Do not commit or share this file."]
+        lines.extend(f"{item_key}={_quote(item_value)}" for item_key, item_value in sorted(secrets.items()))
+        path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+    except OSError as exc:
+        raise ConfigError("Secret lokal gagal disimpan.", f"Path: {path}") from exc
+
+    os.environ[key] = secret
+
+
+def read_secrets(path: Path | None = None) -> dict[str, str]:
+    """Read local secrets without printing or masking them."""
+    path = path or SECRETS_FILE
+    if not path.exists():
+        return {}
+    result: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, value = stripped.split("=", 1)
+        result[key.strip()] = _unquote(value.strip())
+    return result
+
+
+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 read_secrets(path).get(env_key) == current:
+            return "~/.fincli/secrets.env"
+        return "environment/.env"
+    return "-"
+
+
+def _validate_env_key(env_key: str) -> str:
+    key = env_key.strip().upper()
+    if not key or not all(char.isalnum() or char == "_" for char in key):
+        raise ConfigError(f"Nama environment key tidak valid: {env_key}")
+    return key
+
+
+def _sanitize_value(value: str) -> str:
+    return value.strip().replace("\r", "").replace("\n", "")
+
+
+def _quote(value: str) -> str:
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def _unquote(value: str) -> str:
+    if len(value) >= 2 and value[0] == value[-1] == '"':
+        return value[1:-1].replace('\\"', '"').replace("\\\\", "\\")
+    return value

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)

package/fincli/app/tui/layout.py

@@ -7,6 +7,7 @@ from threading import Lock
 
 from textual.app import App, ComposeResult, SystemCommand
 from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.css.query import NoMatches
 from textual.screen import Screen
 from textual.worker import Worker, WorkerState
 from textual.widgets import Header, Input, RichLog, Static
@@ -16,7 +17,7 @@ from fincli.app.cli.autocomplete import SlashAutocomplete
 from fincli.app.cli.commands import CommandRegistry
 from fincli.app.cli.router import CommandResult, CommandRouter
 from fincli.app.providers.ai.manager import AIProviderManager
-from fincli.app.tui.components import CommandPalette, format_ai_message, format_thinking_message, format_user_message
+from fincli.app.tui.components import CommandPalette, format_thinking_message, format_user_message
 from fincli.app.tui.market_provider_selector import MarketProviderSelectorScreen
 from fincli.app.tui.model_selector import AIModelSelectorScreen
 from fincli.app.tui.theme import APP_CSS
@@ -230,8 +231,11 @@ class FinCLIApp(App[None]):
         sequence = int(str(meta.get("sequence", "0")))
         if sequence < self._latest_worker_sequence:
             return
-        output = self.query_one("#output", RichLog)
-        status = self.query_one("#status_bar", Static)
+        try:
+            output = self.query_one("#output", RichLog)
+            status = self.query_one("#status_bar", Static)
+        except NoMatches:
+            return
         display_raw = str(meta["display_raw"])
 
         if event.state == WorkerState.CANCELLED:
@@ -248,10 +252,7 @@ class FinCLIApp(App[None]):
         if result.clear:
             output.clear()
         elif result.renderable:
-            if bool(meta.get("chat")) and result.status == "ready":
-                output.write(format_ai_message(str(result.renderable)))
-            else:
-                output.write(result.renderable)
+            output.write(result.renderable)
 
         if bool(meta.get("chat")):
             status.update(f"{result.status} | ai chat")