aipa-cli 0.1.0__py3-none-any.whl

aipa_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: aipa-cli
+Version: 0.1.0
+Summary: Terminal TUI for AI-powered ticker analysis
+Project-URL: Homepage, https://github.com/quanhua92/aipriceaction
+Project-URL: Repository, https://github.com/quanhua92/aipriceaction
+Author-email: Quan Hua <quanhua92@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.13
+Requires-Dist: aipriceaction
+Requires-Dist: langchain-core
+Requires-Dist: langchain-openai
+Requires-Dist: langgraph
+Requires-Dist: textual-autocomplete>=4.0.6
+Requires-Dist: textual>=3.0.0
+Description-Content-Type: text/markdown
+
+# AIPA Terminal
+
+**Live site:** [aipriceaction.com](https://aipriceaction.com) | **GitHub:** [aipriceaction](https://github.com/quanhua92/aipriceaction) | **Frontend:** [aipriceaction-web](https://github.com/quanhua92/aipriceaction-web) | **Docker image:** [`quanhua92/aipriceaction:latest`](https://hub.docker.com/r/quanhua92/aipriceaction) | **Python SDK:** [`aipriceaction` on PyPI](https://pypi.org/project/aipriceaction/) | **AIPA Terminal:** [`aipa-cli` on PyPI](https://pypi.org/project/aipa-cli/)
+
+Textual-based terminal interface for AI-powered ticker analysis. Features streaming chat with thinking/reasoning display, autocomplete, slash commands, and workflow tabs.
+
+## Install
+
+```bash
+# Run directly (no install)
+uvx aipa-cli
+
+# Or install as a standalone tool
+uv tool install aipa-cli
+```
+
+## Requirements
+
+- Python 3.13+
+- An OpenAI-compatible API key (`OPENAI_API_KEY`)
+- Optional: set `OPENAI_BASE_URL` for custom providers like OpenRouter
+
+## Usage
+
+```
+aipa              # Launch the TUI
+aipa analyze      # Run ticker analysis from CLI
+aipa get-ohlcv-data  # Fetch OHLCV data from CLI
+aipa deep-research   # Run deep research from CLI
+```
+
+### TUI
+
+The interface has three tabs:
+
+- **Chat** — AI-powered chat with streaming responses, thinking/reasoning display, slash commands (`/analyze`, `/export`, `/clear`, `/exit`), and arrow-key history navigation
+- **Workflows** — Structured analysis forms for ticker analysis and deep research
+- **Tickers** — Browse and search available tickers
+
+Press `Ctrl+O` in the Chat tab to view thinking/reasoning history.
+
+## License
+
+MIT

aipa_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+aipriceaction_terminal/__init__.py,sha256=gPrefNl9a5TjwubXBnZDuydjl9V9rfRGjCWXW_APhho,94
+aipriceaction_terminal/__main__.py,sha256=yQP0sf-rkTO-3MOotv4blvukvNGwbJFz10hQhMsxcJM,28
+aipriceaction_terminal/actions.py,sha256=EP6GDpUplKBbiheB_qPP3UL8IgSCypnw6_bIlyHexfE,2424
+aipriceaction_terminal/app.py,sha256=49YIi3OrY7tHKJ1yo-_ZPm6T0r6Ex17VJ7EFENJgcgo,3624
+aipriceaction_terminal/bindings.py,sha256=R7clTVPBbFydXIxqg5ij_D1N9BWmONZ_lEM8Rd_pYPk,1053
+aipriceaction_terminal/chat.py,sha256=EuWWe8uTTp7m-w6hEYFHnmD3zvAz4sgvzYxp8YOhtdI,12708
+aipriceaction_terminal/cli.py,sha256=r53uCIKjLw1wqFGQZ93Z3_z-zA5EXwHHlsikevbx4bU,2484
+aipriceaction_terminal/cli_commands.py,sha256=T6qFNH5rH1Jv1Uo40F1jr0IvUWNDkB3UT5kwZJNqBL0,1477
+aipriceaction_terminal/settings_tab.py,sha256=6WCbc9WEdJXliy0M0mRthtTIN-fEVOxhkpqiQi-RTkg,2590
+aipriceaction_terminal/theme.py,sha256=RKNunhKP30ign3_d6XB_XPGXHCpXAByOMhb4TAKH_eM,488
+aipriceaction_terminal/ticker_data.py,sha256=MqnFM61QCHQdD5xc3P4-ym66WAhLzeTBAzhlWrqtsKc,835
+aipriceaction_terminal/user_settings.py,sha256=Nk7V3PhvrIBM2RruWv85pR-ankwaziaVNbjt98j-pxw,776
+aipriceaction_terminal/utils.py,sha256=hNfwyCVspY4UqLyBfshZ1eoFyBmpO4SCBORgLM9D0HE,958
+aipriceaction_terminal/workflows.py,sha256=g2mq7zuHUFdUHe2r4lRifj6Q21tnUSd1lvvN8vqpFeg,5278
+aipriceaction_terminal/agents/__init__.py,sha256=8XTDmU3oKVaq4S7VCXPgZhKV6R8tQYe6NOkK3vDwDic,555
+aipriceaction_terminal/agents/agent.py,sha256=F0b2MmayxeduI_DksQ1K0r-5u3DNT2qif4gcqqIfVlc,6466
+aipriceaction_terminal/agents/callbacks.py,sha256=rJDepq55WA59PXfXkIK-H-mrnAlNqSQc7qAdr8dSwDo,7995
+aipriceaction_terminal/agents/config.py,sha256=kM_agIqBnZ7tjcw1UkcFudDOmW6nvh4qoHpiX3MDbtQ,891
+aipriceaction_terminal/agents/personas.py,sha256=aE-KCKUVeN8Qh0dNhsnEYtiW8h-aawYjKOQGRU8l1hg,7200
+aipriceaction_terminal/agents/tools.py,sha256=BME0M7bBT5ZioQE3PXcIZNGSDqjwGni5OWySkfK-bEo,4750
+aipriceaction_terminal/widgets/__init__.py,sha256=l6VhmuYHLeOpihfnsRrmJApaH8dNy0sO0mlmM68J_-w,167
+aipriceaction_terminal/widgets/chat_input.py,sha256=ljl9ZPH-sJXXcfPJRWT6lKbz4XKa877KEHUqQhV7wh0,6321
+aipriceaction_terminal/widgets/ticker_select.py,sha256=wqnWwNuG4aQt7KfFjQ3OKyYDnusm2j2AxAULHhAUi9w,6241
+aipa_cli-0.1.0.dist-info/METADATA,sha256=flYRarF2W4TncEobYbgvfnPmcnfdKa5Fi6KNxUWgvk8,2539
+aipa_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+aipa_cli-0.1.0.dist-info/entry_points.txt,sha256=_n1i2eFfJd8t9MP6fMTkgbBrTouLGjfdKR-CU7MqNIo,57
+aipa_cli-0.1.0.dist-info/licenses/LICENSE,sha256=HD6oXFCMoqYOrIATCk8Eh2vZx5IAFhe-NAxxtwIpLBs,1065
+aipa_cli-0.1.0.dist-info/RECORD,,

aipa_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

aipa_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aipa = aipriceaction_terminal.app:main

aipa_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Quan Hua
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aipriceaction_terminal/__init__.py

@@ -0,0 +1,3 @@
+"""AIPriceAction Terminal - TUI chat interface for ticker analysis."""
+
+__version__ = "0.1.0"

aipriceaction_terminal/__main__.py

@@ -0,0 +1,3 @@
+from .cli import run
+
+run()

aipriceaction_terminal/actions.py

@@ -0,0 +1,73 @@
+"""Action handlers for AIPriceActionApp."""
+
+import time
+
+from textual.widgets import TabbedContent, Input, Select, Button, TextArea
+
+
+class AppActions:
+    """Mixin providing all action_* methods for AIPriceActionApp."""
+
+    _quit_requested_at: float = 0.0
+
+    def action_switch_tab(self, tab_id: str) -> None:
+        tabs = self.query_one(TabbedContent)
+        tabs.active = tab_id
+
+    def action_focus_none(self) -> None:
+        """Blur any focused widget, or dismiss a modal if one is showing."""
+        from .chat import ThinkingModal
+        if isinstance(self.screen_stack[-1], ThinkingModal):
+            self.pop_screen()
+            return
+        self.set_focus(None)
+
+    def action_focus_first_input(self) -> None:
+        """Focus the first Input or Select in the active tab (respects nested tabs)."""
+        # Let Enter pass through to widgets that handle it themselves
+        if isinstance(self.focused, (Input, Select, Button, TextArea)):
+            return
+
+        tabs = self.query_one(TabbedContent)
+        active_pane = tabs.query(f"TabPane#{tabs.active}").first()
+        if active_pane is None:
+            return
+
+        # Find the innermost active TabbedContent within this pane
+        container = active_pane
+        try:
+            nested = active_pane.query_one("TabbedContent")
+            inner_pane = nested.query(f"TabPane#{nested.active}").first()
+            if inner_pane:
+                container = inner_pane
+        except Exception:
+            pass
+
+        try:
+            first_input = container.query(Input).first()
+            first_input.focus()
+            return
+        except Exception:
+            pass
+        try:
+            first_select = container.query(Select).first()
+            first_select.focus()
+        except Exception:
+            pass
+
+    def action_confirm_quit(self) -> None:
+        """Quit on second press within 2 seconds, otherwise show warning."""
+        now = time.monotonic()
+        if now - self._quit_requested_at < 2.0:
+            self.exit()
+        else:
+            self._quit_requested_at = now
+            self.notify("Press ctrl+q again to quit", severity="warning")
+
+    def action_show_help(self) -> None:
+        self.app.notify(
+            "1-6: Switch tabs | ctrl+q: Quit | "
+            "esc: Back | enter: Focus input | "
+            "Chat: /help for commands",
+            title="Keyboard Shortcuts",
+        )

aipriceaction_terminal/agents/__init__.py

@@ -0,0 +1,20 @@
+"""Agents module for AI-powered chat in the terminal TUI."""
+
+from .agent import AgentSession
+from .callbacks import StreamCallbackHandler, StreamEvent, StreamEventType
+from .config import AgentConfig
+from .personas import Persona, PersonaRegistry, get_default_persona
+from .tools import ToolRegistry, get_default_tools
+
+__all__ = [
+    "AgentSession",
+    "AgentConfig",
+    "Persona",
+    "PersonaRegistry",
+    "get_default_persona",
+    "ToolRegistry",
+    "get_default_tools",
+    "StreamCallbackHandler",
+    "StreamEvent",
+    "StreamEventType",
+]

aipriceaction_terminal/agents/agent.py

@@ -0,0 +1,175 @@
+"""Agent session: wraps LangChain create_agent with streaming and retry."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any
+
+from langchain.agents import create_agent
+from langchain_core.messages import AIMessageChunk
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+
+from .callbacks import StreamCallbackHandler, StreamEvent, StreamEventType
+from .config import AgentConfig, TRANSIENT_ERROR_KEYWORDS
+
+if TYPE_CHECKING:
+    from .personas import Persona
+    from .tools import ToolRegistry
+
+
+class OpenRouterChatOpenAI(ChatOpenAI):
+    """ChatOpenAI subclass that preserves reasoning tokens from OpenRouter.
+
+    OpenRouter reasoning models (e.g. nvidia/nemotron-3-nano-omni-reasoning) return
+    a ``reasoning`` string field in the streaming delta.  LangChain's default
+    ``_convert_delta_to_message_chunk`` ignores this field, so we override
+    ``_convert_chunk_to_generation_chunk`` to inject it into
+    ``AIMessageChunk.additional_kwargs["reasoning_content"]`` after the chunk is built.
+    """
+
+    def _convert_chunk_to_generation_chunk(
+        self,
+        chunk: dict[str, Any],
+        default_chunk_class: type,
+        base_generation_info: dict[str, Any] | None,
+    ) -> Any:
+        """Build the generation chunk, then inject reasoning into additional_kwargs."""
+        result = super()._convert_chunk_to_generation_chunk(
+            chunk, default_chunk_class, base_generation_info
+        )
+        if result is None:
+            return result
+
+        # Extract reasoning from the raw delta before LangChain discards it.
+        choices = chunk.get("choices", [])
+        if choices:
+            delta = choices[0].get("delta")
+            if isinstance(delta, dict):
+                reasoning = delta.get("reasoning")
+                if reasoning and isinstance(result.message, AIMessageChunk):
+                    result.message.additional_kwargs["reasoning_content"] = reasoning
+
+        return result
+
+
+class AgentSession:
+    """Manages a single agent session with memory, streaming, and retry."""
+
+    def __init__(
+        self,
+        config: AgentConfig,
+        persona: Persona | None = None,
+        tools: ToolRegistry | None = None,
+    ) -> None:
+        from .personas import get_default_persona
+        from .tools import get_default_tools
+
+        self.config = config
+        self.persona = persona or get_default_persona(config.lang)
+        self.tools = tools or get_default_tools(config.lang)
+        self._checkpointer = MemorySaver()
+        self._thread_id = "terminal-default"
+        self._agent = self._build_agent()
+
+    def _build_agent(self) -> object:
+        """Build the LangChain agent from current config/persona/tools."""
+        llm = OpenRouterChatOpenAI(
+            api_key=self.config.api_key,
+            base_url=self.config.base_url,
+            model=self.config.model,
+            extra_body={"reasoning": {"enabled": True}},
+        )
+        system_prompt = self.persona.build_system_prompt(self.config.lang)
+        lc_tools = self.tools.get_tools()
+
+        return create_agent(
+            llm,
+            lc_tools,
+            checkpointer=self._checkpointer,
+            system_prompt=system_prompt,
+        )
+
+    async def stream(
+        self,
+        message: str,
+        *,
+        callback: object | None = None,
+    ) -> AsyncIterator[StreamEvent]:
+        """Stream an agent response as StreamEvents.
+
+        Built-in retry with exponential backoff on transient errors.
+        """
+        handler = StreamCallbackHandler(
+            show_tool_calls=True,
+            show_tool_results=False,
+        )
+
+        last_error: Exception | None = None
+        for attempt in range(self.config.max_retries):
+            try:
+                input_dict = {"messages": [{"role": "user", "content": message}]}
+                config = {"configurable": {"thread_id": self._thread_id}}
+
+                async for lc_event in self._agent.astream(
+                    input_dict,
+                    config=config,
+                    stream_mode="messages",
+                ):
+                    for stream_event in handler.process_agent_event(lc_event):
+                        if callback:
+                            await callback(stream_event)
+                        yield stream_event
+
+                yield StreamEvent(type=StreamEventType.DONE)
+                return
+
+            except Exception as e:
+                last_error = e
+                err_str = str(e).lower()
+                is_transient = any(kw in err_str for kw in TRANSIENT_ERROR_KEYWORDS)
+
+                if is_transient and attempt < self.config.max_retries - 1:
+                    delay = self.config.base_retry_delay * (2 ** attempt)
+                    delay = min(delay, self.config.max_retry_delay)
+                    yield StreamEvent(
+                        type=StreamEventType.ERROR,
+                        content=f"Retry {attempt + 1}/{self.config.max_retries}: {type(e).__name__}",
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    break
+
+        # All retries exhausted
+        yield StreamEvent(
+            type=StreamEventType.ERROR,
+            content=f"Error: {last_error}",
+        )
+        yield StreamEvent(type=StreamEventType.DONE)
+
+    async def run(self, message: str) -> str:
+        """Convenience wrapper: collect tokens and return the final answer."""
+        parts: list[str] = []
+        async for event in self.stream(message):
+            if event.type == StreamEventType.TOKEN:
+                parts.append(event.content)
+
+        # Return the longest part (final answer after potential re-generation)
+        return max(parts, key=len) if parts else ""
+
+    def switch_persona(self, persona: Persona) -> None:
+        """Switch to a different persona, clearing conversation history."""
+        self.persona = persona
+        self._checkpointer = MemorySaver()
+        self._agent = self._build_agent()
+
+    def clear_history(self) -> None:
+        """Clear conversation history (start fresh session)."""
+        self._checkpointer = MemorySaver()
+        self._agent = self._build_agent()
+
+    def rebuild(self) -> None:
+        """Rebuild agent after config change (language/model)."""
+        self._checkpointer = MemorySaver()
+        self._agent = self._build_agent()

aipriceaction_terminal/agents/callbacks.py

@@ -0,0 +1,202 @@
+"""Stream events and callback handler for TUI integration."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class StreamEventType(Enum):
+    TOKEN = "token"
+    THINKING = "thinking"
+    TOOL_CALL_START = "tool_call_start"
+    TOOL_RESULT = "tool_result"
+    ERROR = "error"
+    DONE = "done"
+
+
+@dataclass
+class StreamEvent:
+    """A single event from the agent stream."""
+
+    type: StreamEventType
+    content: str = ""
+    metadata: dict = field(default_factory=dict)
+
+
+StreamCallback = Callable[[StreamEvent], Awaitable[None]]
+
+
+def _extract_reasoning_content(message: Any) -> str:
+    """Extract reasoning/thinking content from an AIMessageChunk.
+
+    Checks multiple fields where different providers store reasoning tokens:
+    - ``additional_kwargs["reasoning_content"]`` — OpenRouter, DeepSeek, XAI, Groq
+    - ``content_blocks`` with ``type="reasoning"`` — Anthropic, OpenAI
+    """
+    # Check additional_kwargs first (most common for OpenAI-compatible providers)
+    ak = getattr(message, "additional_kwargs", None)
+    if ak and isinstance(ak, dict) and "reasoning_content" in ak:
+        content = ak["reasoning_content"]
+        if content:
+            return content
+
+    # Check content_blocks for type="reasoning"
+    blocks = getattr(message, "content_blocks", None)
+    if blocks:
+        for block in blocks:
+            if isinstance(block, dict) and block.get("type") == "reasoning":
+                text = block.get("reasoning", "")
+                if text:
+                    return text
+            elif hasattr(block, "type") and block.type == "reasoning":
+                text = getattr(block, "reasoning", "")
+                if text:
+                    return text
+
+    return ""
+
+
+class StreamCallbackHandler:
+    """Converts LangChain/LangGraph stream events to StreamEvents for TUI rendering.
+
+    Supports ``stream_mode="messages"`` (token-by-token) and
+    ``stream_mode="updates"`` (batched per node).
+    """
+
+    def __init__(
+        self,
+        *,
+        show_tool_calls: bool = True,
+        show_tool_results: bool = False,
+    ) -> None:
+        self.show_tool_calls = show_tool_calls
+        self.show_tool_results = show_tool_results
+        # Buffer tool calls during streaming; keyed by tool_call_id.
+        # Values accumulate raw args string from tool_call_chunks.
+        self._pending_tool_calls: dict[str, dict[str, str]] = {}
+        # OpenAI streaming only sends `id` on the first chunk per tool call.
+        # Subsequent chunks carry only `index` + partial `args`.
+        # This maps index → tool_call_id so we can associate them.
+        self._index_to_id: dict[int, str] = {}
+
+    def process_agent_event(self, event: Any) -> list[StreamEvent]:
+        """Convert a single LangGraph stream event to StreamEvents.
+
+        ``stream_mode="messages"`` yields tuples::
+
+            (AIMessageChunk(content="Hello"), metadata_dict)
+
+        ``stream_mode="updates"`` yields ``UpdatesStreamPart`` dicts::
+
+            {"agent": {"messages": [AIMessage(...)]}}
+        """
+        events: list[StreamEvent] = []
+
+        # Handle stream_mode="messages" — yields (message, metadata) tuples
+        if isinstance(event, tuple) and len(event) == 2:
+            message, _metadata = event
+            return self._process_message(message)
+
+        # Handle stream_mode="updates" — yields dicts like {"agent": {"messages": [...]}}
+        if isinstance(event, dict):
+            for _node_name, update in event.items():
+                for msg in update.get("messages", []):
+                    events.extend(self._process_message(msg))
+            return events
+
+        return events
+
+    def _process_message(self, message: Any) -> list[StreamEvent]:
+        """Process a single message (AIMessageChunk or ToolMessage)."""
+        events: list[StreamEvent] = []
+        msg_type = type(message).__name__
+
+        if msg_type in ("AIMessageChunk", "AIMessage"):
+            # Reasoning/thinking tokens
+            reasoning = _extract_reasoning_content(message)
+            if reasoning:
+                events.append(StreamEvent(
+                    type=StreamEventType.THINKING,
+                    content=reasoning,
+                ))
+
+            # Tool calls — accumulate raw chunks, emit parsed call when ToolMessage arrives
+            tool_call_chunks = getattr(message, "tool_call_chunks", None)
+            if tool_call_chunks:
+                for tc_chunk in tool_call_chunks:
+                    _get = tc_chunk.get if isinstance(tc_chunk, dict) else lambda k, d=None: getattr(tc_chunk, k, d)
+                    tc_id = _get("id") or ""
+                    tc_index = _get("index")
+
+                    # First chunk has id + index → record the mapping
+                    if tc_id and tc_index is not None:
+                        self._index_to_id[tc_index] = tc_id
+                    # Subsequent chunks only have index → look up the id
+                    elif not tc_id and tc_index is not None:
+                        tc_id = self._index_to_id.get(tc_index, "")
+
+                    if not tc_id:
+                        continue
+                    if tc_id not in self._pending_tool_calls:
+                        self._pending_tool_calls[tc_id] = {"name": "", "args_str": ""}
+                    entry = self._pending_tool_calls[tc_id]
+                    chunk_name = _get("name") or ""
+                    if chunk_name:
+                        entry["name"] = chunk_name
+                    chunk_args = _get("args") or ""
+                    if chunk_args:
+                        entry["args_str"] += chunk_args
+            elif getattr(message, "tool_calls", None):
+                # Fallback for non-streaming AIMessage (e.g. stream_mode="updates")
+                for tc in message.tool_calls:
+                    tc_id = tc.get("id", "")
+                    if not tc_id:
+                        continue
+                    if tc_id not in self._pending_tool_calls:
+                        self._pending_tool_calls[tc_id] = {"name": "", "args_str": ""}
+                    entry = self._pending_tool_calls[tc_id]
+                    if tc.get("name"):
+                        entry["name"] = tc["name"]
+                    if isinstance(tc.get("args"), dict):
+                        entry["args_str"] = json.dumps(tc["args"], ensure_ascii=False)
+
+            # Content tokens (partial chunks from streaming)
+            if message.content:
+                events.append(StreamEvent(
+                    type=StreamEventType.TOKEN,
+                    content=message.content,
+                ))
+
+        elif msg_type in ("ToolMessage",):
+            # Flush buffered tool call now that execution is complete
+            tc_id = getattr(message, "tool_call_id", "")
+            if tc_id and tc_id in self._pending_tool_calls and self.show_tool_calls:
+                tc_info = self._pending_tool_calls.pop(tc_id)
+                raw_args = tc_info.get("args_str", "")
+                try:
+                    args = json.loads(raw_args) if raw_args else {}
+                except json.JSONDecodeError:
+                    args = {}
+                args_preview = json.dumps(args, ensure_ascii=False)
+                events.append(StreamEvent(
+                    type=StreamEventType.TOOL_CALL_START,
+                    content=f"{tc_info['name']}({args_preview})",
+                ))
+
+            if self.show_tool_results:
+                events.append(StreamEvent(
+                    type=StreamEventType.TOOL_RESULT,
+                    content=message.content,
+                ))
+            else:
+                char_count = len(message.content)
+                events.append(StreamEvent(
+                    type=StreamEventType.TOOL_RESULT,
+                    content=f"[{char_count:,} chars]",
+                ))
+
+        return events

aipriceaction_terminal/agents/config.py

@@ -0,0 +1,35 @@
+"""Agent configuration: reads from SDK settings."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from aipriceaction.settings import settings
+
+
+@dataclass(frozen=True)
+class AgentConfig:
+    """Configuration for an agent session.
+
+    Reads defaults from the SDK settings singleton (same .env the SDK uses).
+    """
+
+    api_key: str = field(default_factory=lambda: settings.openai_api_key)
+    base_url: str = field(default_factory=lambda: settings.openai_base_url)
+    model: str = field(default_factory=lambda: settings.openai_model)
+    lang: str = field(default_factory=lambda: settings.ai_context_lang)
+    max_retries: int = 3
+    base_retry_delay: float = 5.0
+    max_retry_delay: float = 60.0
+
+
+TRANSIENT_ERROR_KEYWORDS: tuple[str, ...] = (
+    "429",
+    "500",
+    "502",
+    "503",
+    "504",
+    "timeout",
+    "connection",
+    "overloaded",
+)