padwan-cli 0.2.2__tar.gz → 0.3.0__tar.gz

padwan_cli-0.3.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.3
+Name: padwan-cli
+Version: 0.3.0
+Summary: CLI and TUI for padwan-llm
+Author-email: julien.brayere@polarsen.com
+Requires-Dist: padwan-llm>=0.6.0
+Requires-Dist: piou[tui]>=0.34.1
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# Padwan CLI
+
+Interactive CLI/TUI for [`padwan-llm`](https://github.com/polarsen-io/padwan-llm).
+
+> [!NOTE]
+> This is a playground for experimenting with `padwan-llm` features (streaming, agents, MCP, thinking tokens, batch jobs) — not a production-grade tool. Expect rough edges and breaking changes.
+
+<img alt="Chat demo" src="https://github.com/polarsen-io/padwan-cli/raw/master/docs/static/chat.gif" width="800"/>
+
+## Quick start
+
+```bash
+export OPENAI_API_KEY=...
+uvx padwan-cli
+# then /help for commands
+```
+
+
+## Install
+
+```bash
+pip install padwan-cli
+```
+
+## Local Development
+
+```bash
+uv sync --group dev
+uv run padwan-cli
+```
+
+## One-shot Mode
+
+```bash
+uvx padwan-cli "Hello" -m gpt-4o-mini
+```

padwan_cli-0.3.0/README.md

@@ -0,0 +1,36 @@
+# Padwan CLI
+
+Interactive CLI/TUI for [`padwan-llm`](https://github.com/polarsen-io/padwan-llm).
+
+> [!NOTE]
+> This is a playground for experimenting with `padwan-llm` features (streaming, agents, MCP, thinking tokens, batch jobs) — not a production-grade tool. Expect rough edges and breaking changes.
+
+<img alt="Chat demo" src="https://github.com/polarsen-io/padwan-cli/raw/master/docs/static/chat.gif" width="800"/>
+
+## Quick start
+
+```bash
+export OPENAI_API_KEY=...
+uvx padwan-cli
+# then /help for commands
+```
+
+
+## Install
+
+```bash
+pip install padwan-cli
+```
+
+## Local Development
+
+```bash
+uv sync --group dev
+uv run padwan-cli
+```
+
+## One-shot Mode
+
+```bash
+uvx padwan-cli "Hello" -m gpt-4o-mini
+```

{padwan_cli-0.2.2 → padwan_cli-0.3.0}/padwan_cli/batch/run.py

@@ -38,7 +38,7 @@ async def batch_create(
         None, "-f", "--file", help="Read prompts from JSON/text file"
     ),
     model: str = Option(
-        "gemini-2.0-flash",
+        "gemini-2.5-flash",
         "-m",
         "--model",
         help="Model to use",

padwan_cli-0.3.0/padwan_cli/chat.py

@@ -0,0 +1,260 @@
+import contextlib
+import json
+import time
+from contextlib import contextmanager
+from typing import Any
+
+from piou import Option, CommandGroup
+from piou.tui import PromptStyle, TuiContext, TuiOption
+from textual.css.query import NoMatches
+
+from padwan_llm import (
+    AgentSession,
+    ConversationSnapshot,
+    LLMClient,
+    McpStreamable,
+    McpTool,
+    McpTransport,
+    ToolCallContext,
+)
+from padwan_llm.gemini import GeminiClient
+from padwan_llm.gemini.models import ThinkingConfig
+from .utils import ALL_MODELS, console
+from .widgets import StreamingMessage, ThoughtMessage, ToolCallMessage, UserMessage
+
+chat_group = CommandGroup(name="chat", help="Chat with an LLM")
+
+# Public, no-auth streamable-HTTP MCP server for data.gouv.fr
+DATAGOUV_MCP_URL = "https://mcp.data.gouv.fr/mcp"
+
+
+class _InMemoryStore:
+    """ConversationStore keeping snapshots in memory across /chat:send calls.
+
+    Implements the `padwan_llm.ConversationStore` protocol so that
+    `AgentSession.load` / `AgentSession.save` transparently preserve chat
+    history across successive command invocations within the same TUI run.
+    """
+
+    def __init__(self) -> None:
+        self._data: dict[str, ConversationSnapshot] = {}
+
+    def save(self, session_id: str, snapshot: ConversationSnapshot) -> None:
+        self._data[session_id] = snapshot
+
+    def load(self, session_id: str) -> ConversationSnapshot:
+        return self._data[session_id]
+
+    def forget(self, session_id: str | None) -> bool:
+        """Drop one or all snapshots; return True if anything was removed."""
+        if session_id is None:
+            existed = bool(self._data)
+            self._data.clear()
+            return existed
+        return self._data.pop(session_id, None) is not None
+
+
+_store = _InMemoryStore()
+
+CHAT_PROMPT = PromptStyle(text="You: ", css_class="chat-mode")
+
+
+def _format_tokens(session: AgentSession, ctx: TuiContext | None = None) -> str:
+    """Format token usage and connected MCP count for display."""
+    if not session.last_usage:
+        return ""
+    last = session.last_usage
+    total = session.total_usage
+    parts = [f"in: {last['input']}", f"out: {last['output']}"]
+    if "cached" in last:
+        parts.append(f"cached: {last['cached']}")
+    parts.append(f"| session: {total['total']}")
+    # Count MCP transports (each represents a connected server); standalone
+    # McpTool entries in mcp_tools are individual tool definitions, not servers.
+    mcp_count = sum(1 for t in session.mcp_tools if not isinstance(t, McpTool))
+    if mcp_count:
+        parts.append(f"| mcp: {mcp_count}")
+    if ctx and ctx.pending_count > 0:
+        parts.append(f"| {ctx.pending_count} queued")
+    return " ".join(parts)
+
+
+@chat_group.command("send", help="Send a message to the LLM")
+async def chat_send_fn(
+    message: str = Option(..., help="Message to send"),
+    model: str = Option("gpt-4o-mini", "-m", "--model", help="Model to use"),
+    session_id: str | None = Option(None, "--resume", help="Resume session"),
+    max_tool_rounds: int = Option(
+        20, "--max-tools-round", help="Maximum number of tool calls per round"
+    ),
+    base_url: str | None = Option(
+        None, "--base-url", help="Custom OpenAI-compatible endpoint"
+    ),
+    extra_params: str | None = Option(
+        None,
+        "--extra-params",
+        help="Extra JSON object merged into every request body (e.g. '{\"temperature\": 0}')",
+    ),
+    ctx: TuiContext = TuiOption(),
+) -> None:
+    """Start a conversation. Use Ctrl+C to exit."""
+
+    # Tracks whether the next text chunk should start a fresh streaming
+    # widget. Mounted widgets keep their position in the message scroll, so
+    # if we mounted a single StreamingMessage up-front any tool/thought
+    # widgets fired mid-stream would land *below* the (still empty) text
+    # placeholder — making the final answer appear above the tool calls
+    # that produced it. Resetting this flag on every event splits the text
+    # into one widget per "section" with tool/thought widgets between them.
+    needs_new_text_widget = True
+    # Consecutive thought chunks stream into the same widget; any non-thought
+    # event (tool call or text chunk) closes the current thought block so
+    # the next thought starts a fresh widget.
+    current_thought: ThoughtMessage | None = None
+
+    @contextmanager
+    def _on_tool(tc: ToolCallContext):
+        nonlocal needs_new_text_widget, current_thought
+        current_thought = None
+        if ctx.is_tui:
+            widget = ToolCallMessage(tc.name, tc.args)
+            ctx.mount_widget(widget)
+            needs_new_text_widget = True
+            t0 = time.perf_counter()
+            yield
+            widget.set_elapsed(time.perf_counter() - t0)
+        else:
+            console.print(f"[dim]→ tool call: {tc.name}({tc.args})[/dim]")
+            t0 = time.perf_counter()
+            yield
+            console.print(f"[dim]  ↳ {time.perf_counter() - t0:.1f}s[/dim]")
+
+    def _on_thought(text: str) -> None:
+        nonlocal needs_new_text_widget, current_thought
+        if ctx.is_tui:
+            if current_thought is None:
+                current_thought = ThoughtMessage(text)
+                ctx.mount_widget(current_thought)
+            else:
+                current_thought.append(text)
+            needs_new_text_widget = True
+        else:
+            console.print(f"[dim italic]💭 {text}[/dim italic]", end="")
+
+    def _on_mcp_connect(transport: McpTransport) -> None:
+        if ctx.is_tui:
+            ctx.notify(transport.label, title="MCP connected")
+        else:
+            console.print(f"[green]MCP connected[/green] [dim]{transport.label}[/dim]")
+
+    parsed_extra: dict[str, Any] | None = None
+    if extra_params is not None:
+        try:
+            parsed_extra = json.loads(extra_params)
+        except json.JSONDecodeError as e:
+            console.print(f"[red]--extra-params is not valid JSON: {e}[/red]")
+            return
+        if not isinstance(parsed_extra, dict):
+            console.print("[red]--extra-params must be a JSON object[/red]")
+            return
+
+    try:
+        client = LLMClient(model=model, on_thought=_on_thought, base_url=base_url)
+        if isinstance(client, GeminiClient):
+            client.thinking_config = ThinkingConfig(includeThoughts=True)
+
+        # `--resume` lets the user pick an explicit session id; otherwise we
+        # key history by model so a second `/chat:send` continues the same
+        # conversation (and `chat_clear_fn` can target it by model name).
+        # `AgentSession.load` treats a missing snapshot as get-or-create, so
+        # the first turn under a new id lands in the store via `session.save()`.
+        session = AgentSession.load(
+            client=client,
+            mcp_tools=[McpStreamable(url=DATAGOUV_MCP_URL)],
+            on_tool=_on_tool,
+            on_mcp_connect=_on_mcp_connect,
+            store=_store,
+            session_id=session_id or model,
+            max_tool_rounds=max_tool_rounds,
+            extra_params=parsed_extra,
+        )
+        async with session:
+            user_input: str | None = message
+            original_style = ctx.set_prompt_style(CHAT_PROMPT)
+            ctx.set_hint("Chat mode - press Ctrl+C to exit")
+            ctx.set_rule_above(add_class="chat-mode")
+            ctx.set_rule_below(add_class="chat-mode")
+
+            try:
+                while user_input:
+                    if ctx.is_tui:
+                        ctx.mount_widget(UserMessage(user_input))
+                        ctx.set_hint("Responding...")
+                        ctx.set_silent_queue(True)
+                        needs_new_text_widget = True
+                        widget: StreamingMessage | None = None
+                        async for chunk in session.stream(user_input):
+                            if needs_new_text_widget:
+                                widget = StreamingMessage()
+                                ctx.mount_widget(widget)
+                                needs_new_text_widget = False
+                                current_thought = None
+                            assert widget is not None
+                            widget.append(chunk)
+                            if (n := ctx.pending_count) > 0:
+                                ctx.set_hint(f"Responding... ({n} queued)")
+                        ctx.set_silent_queue(False)
+                        ctx.set_hint("Chat mode - press Ctrl+C to exit")
+                        ctx.set_status_above(_format_tokens(session, ctx) or None)
+                        user_input = await ctx.prompt()
+                    else:
+                        async for chunk in session.stream(user_input):
+                            console.print(chunk, end="")
+                        console.print()
+                        if tokens := _format_tokens(session):
+                            console.print(f"[dim]{tokens}[/dim]")
+                        break
+            finally:
+                session.save()
+                # Cleanup is best-effort — on a double-Ctrl+C the TUI screen
+                # is already tearing down, so query_one("#status-above") and
+                # friends raise NoMatches. Don't surface that as a misleading
+                # "chat session failed" on what was actually a clean exit.
+                with contextlib.suppress(NoMatches):
+                    ctx.set_silent_queue(False)
+                    ctx.clear_queue()  # Discard any messages typed during streaming
+                    ctx.set_status_above(None)
+                    ctx.set_hint(None)
+                    ctx.set_rule_above(remove_class="chat-mode")
+                    ctx.set_rule_below(remove_class="chat-mode")
+                    if original_style:
+                        ctx.set_prompt_style(original_style)
+    except Exception as e:
+        console.print_exception(show_locals=False)
+        console.print(f"[red]Chat session failed: {e}[/red]")
+
+
+@chat_group.command("clear", help="Clear conversation history")
+async def chat_clear_fn(
+    model: str | None = Option(
+        None,
+        "-m",
+        "--model",
+        help="Model session to clear (all if omitted)",
+        choices=ALL_MODELS,
+    ),
+    ctx: TuiContext = TuiOption(),
+) -> None:
+    """Clear conversation history for a model or all models."""
+    if model:
+        if _store.forget(model):
+            ctx.notify(f"Cleared history for {model}", title="Chat")
+            print(f"Cleared conversation history for {model}")
+        else:
+            print(f"No active session for {model}")
+    else:
+        if _store.forget(None):
+            ctx.notify("Cleared all chat history", title="Chat")
+            print("Cleared all conversation history")
+        else:
+            print("No chat history to clear")

{padwan_cli-0.2.2 → padwan_cli-0.3.0}/padwan_cli/run.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import json
 import sys
+from typing import Any
 
 from piou import Cli, Option
+from piou.tui import get_tui_context
 
 from rich.table import Table
 
@@ -13,10 +16,11 @@ from padwan_llm import (
     OPENAI_MODELS,
     LLMClient,
 )
+from padwan_llm._base import OnThought
 from padwan_llm.conversation import Message
 from padwan_llm.errors import Provider
 
-from .utils import ALL_MODELS, console
+from .utils import console
 from .batch import batch_group
 from .chat import chat_group
 
@@ -32,6 +36,12 @@ cli.add_command_group(batch_group)
 cli.add_command_group(chat_group)
 
 
+@cli.tui_on_ready
+def _tui_startup_hint() -> None:
+    """Show a hint pointing new users at the command palette when the TUI opens."""
+    get_tui_context().set_hint("Type / to browse commands - e.g. /chat:send 'Hello'")
+
+
 @cli.command("models", help="List available models")
 def list_models(
     provider: Provider | None = Option(
@@ -88,17 +98,45 @@ def info() -> None:
 @cli.main(help="One-shot LLM query")
 async def oneshot(
     prompt: str = Option(..., help="Prompt to send"),
-    model: str = Option(
-        "gpt-4o-mini", "-m", "--model", help="Model to use", choices=ALL_MODELS
-    ),
+    model: str = Option("gpt-4o-mini", "-m", "--model", help="Model to use"),
     stream: bool = Option(False, "--stream", "-s", help="Stream output as it arrives"),
+    base_url: str | None = Option(
+        None, "--base-url", help="Custom OpenAI-compatible endpoint"
+    ),
+    extra_params: str | None = Option(
+        None,
+        "--extra-params",
+        help="Extra JSON object merged into the request body (e.g. '{\"temperature\": 0}')",
+    ),
+    stream_thinking: bool = Option(
+        False,
+        "--stream-thinking",
+        help="Stream model reasoning/thinking tokens to stderr (requires --stream)",
+    ),
 ) -> None:
     """Send a single prompt and print the response."""
-    client = LLMClient(model=model)
+    parsed_extra: dict[str, Any] | None = None
+    if extra_params is not None:
+        try:
+            parsed_extra = json.loads(extra_params)
+        except json.JSONDecodeError as e:
+            console.print(f"[red]--extra-params is not valid JSON: {e}[/red]")
+            raise SystemExit(1)
+        if not isinstance(parsed_extra, dict):
+            console.print("[red]--extra-params must be a JSON object[/red]")
+            raise SystemExit(1)
+
+    def _thought_streamer(chunk: str) -> None:
+        sys.stderr.write(chunk)
+        sys.stderr.flush()
+
+    on_thought: OnThought | None = _thought_streamer if stream_thinking else None
+
+    client = LLMClient(model=model, base_url=base_url, on_thought=on_thought)
     messages: list[Message] = [Message(role="user", content=prompt)]
     async with client:
         if stream:
-            async for chunk in client.stream_chat(messages):
+            async for chunk in client.stream_chat(messages, extra_params=parsed_extra):
                 sys.stdout.write(chunk)
                 sys.stdout.flush()
         else:

{padwan_cli-0.2.2 → padwan_cli-0.3.0}/padwan_cli/widgets.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+import json
+from typing import TYPE_CHECKING, Any, cast
 
 from rich.text import Text
 from textual.widgets import Static
@@ -13,6 +14,8 @@ if TYPE_CHECKING:
 # Colors for chat messages
 USER_COLOR = "#87ceeb"
 ASSISTANT_COLOR = "#98fb98"
+TOOL_CALL_COLOR = "#ffa500"
+THOUGHT_COLOR = "#9370db"
 
 # Colors for batch job states
 STATE_COLORS = {
@@ -34,6 +37,53 @@ class UserMessage(Static):
         super().__init__(text, **kwargs)
 
 
+class ToolCallMessage(Static):
+    """A styled widget for displaying an MCP tool call inline in the chat.
+
+    Shows the tool name and a truncated one-line preview of its arguments,
+    so the user can actually see when the agent reaches out to an MCP server
+    mid-response (toast notifications are easy to miss).
+    """
+
+    _MAX_ARGS_CHARS = 120
+
+    def __init__(self, name: str, args: dict[str, Any], **kwargs) -> None:
+        self._tool_name = name
+        args_str = json.dumps(args, ensure_ascii=False, sort_keys=True)
+        if len(args_str) > self._MAX_ARGS_CHARS:
+            args_str = args_str[: self._MAX_ARGS_CHARS - 1] + "…"
+        self._args_str = args_str
+        text = Text(f"\u26a1 {name}({args_str})", style=TOOL_CALL_COLOR)
+        super().__init__(text, **kwargs)
+
+    def set_elapsed(self, seconds: float) -> None:
+        """Append elapsed time in dim style."""
+        text = Text()
+        text.append(
+            f"\u26a1 {self._tool_name}({self._args_str})", style=TOOL_CALL_COLOR
+        )
+        text.append(f"  {seconds:.1f}s", style="dim")
+        self.update(text)
+
+
+class ThoughtMessage(Static):
+    """A styled widget for displaying a model reasoning/thought block.
+
+    Providers stream reasoning/thoughts in small chunks. `append` grows the
+    widget in place so a continuous thought renders as one block instead
+    of one widget per chunk.
+    """
+
+    def __init__(self, content: str = "", **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._text = content
+        self.update(Text(f"\U0001f4ad {self._text}", style=f"italic {THOUGHT_COLOR}"))
+
+    def append(self, text: str) -> None:
+        self._text += text
+        self.update(Text(f"\U0001f4ad {self._text}", style=f"italic {THOUGHT_COLOR}"))
+
+
 class StreamingMessage(_StreamingMessage):
     """Streaming message with assistant color styling.
 
@@ -131,7 +181,7 @@ class BatchResultWidget(Static):
         for result in self._results:
             # Header with key and token info
             lines.append(
-                f"[cyan][{result.key}][/cyan] "
+                f"[cyan]\\[{result.key}][/cyan] "
                 f"[dim]({result.input_tokens} in, {result.output_tokens} out, "
                 f"{result.total_tokens} total tokens)[/dim]"
             )

{padwan_cli-0.2.2 → padwan_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "padwan-cli"
-version = "0.2.2"
+version = "0.3.0"
 description = "CLI and TUI for padwan-llm"
 readme = "README.md"
 authors = [
@@ -8,8 +8,8 @@ authors = [
 ]
 requires-python = ">=3.14"
 dependencies = [
-    "padwan-llm>=0.1.0",
-    "piou[tui]>=0.32.0",
+    "padwan-llm>=0.6.0",
+    "piou[tui]>=0.34.1",
 ]
 
 [project.scripts]
@@ -22,18 +22,20 @@ build-backend = "uv_build"
 [tool.uv.build-backend]
 module-root = ""
 
-[tool.uv.sources]
-padwan-llm = { path = "../padwan-llm", editable = true }
+#[tool.uv.sources]
+#padwan-llm = { path = "../padwan-llm", editable = true }
 
 [dependency-groups]
 dev = [
     "piou[tui-reload]>=0.33.0",
+    "pyright>=1.1.408",
     "pytest>=8.0.0",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=7.0.0",
     "ruff>=0.11.0",
 ]
 docs = [
-    "mkdocs>=1.6.0",
-    "mkdocs-material>=9.5.0",
+    "zensical>=0.0.31",
 ]
 bump = [
     "commitizen>=4.0.0",
@@ -45,3 +47,6 @@ version_provider = "pep621"
 tag_format = "$version"
 update_changelog_on_bump = true
 bump_message = "chore(release): release $current_version → $new_version [skip ci]"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

padwan_cli-0.2.2/PKG-INFO

@@ -1,43 +0,0 @@
-Metadata-Version: 2.3
-Name: padwan-cli
-Version: 0.2.2
-Summary: CLI and TUI for padwan-llm
-Author-email: julien.brayere@polarsen.com
-Requires-Dist: padwan-llm>=0.1.0
-Requires-Dist: piou[tui]>=0.32.0
-Requires-Python: >=3.14
-Description-Content-Type: text/markdown
-
-# Padwan CLI
-
-Interactive CLI/TUI for `padwan-llm`.
-
-<img alt="Chat demo" src="https://github.com/Polarsen/padwan-cli/raw/master/docs/static/chat.gif" width="800"/>
-
-## Quick start
-
-```bash
-export OPENAI_API_KEY=...
-uvx padwan-cli
-# then /help for commands
-```
-
-
-## Install
-
-```bash
-pip install padwan-cli
-```
-
-## Local Development
-
-```bash
-uv sync --group dev
-uv run padwan-cli
-```
-
-## One-shot Mode
-
-```bash
-uvx padwan-cli "Hello" -m gpt-4o-mini
-```

padwan_cli-0.2.2/README.md

@@ -1,33 +0,0 @@
-# Padwan CLI
-
-Interactive CLI/TUI for `padwan-llm`.
-
-<img alt="Chat demo" src="https://github.com/Polarsen/padwan-cli/raw/master/docs/static/chat.gif" width="800"/>
-
-## Quick start
-
-```bash
-export OPENAI_API_KEY=...
-uvx padwan-cli
-# then /help for commands
-```
-
-
-## Install
-
-```bash
-pip install padwan-cli
-```
-
-## Local Development
-
-```bash
-uv sync --group dev
-uv run padwan-cli
-```
-
-## One-shot Mode
-
-```bash
-uvx padwan-cli "Hello" -m gpt-4o-mini
-```

padwan_cli-0.2.2/padwan_cli/chat.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from piou import Option, CommandGroup
-from piou.tui import PromptStyle, TuiContext, TuiOption
-
-from padwan_llm import LLMClient
-
-from .utils import ALL_MODELS, console
-from .conversation import Conversation, Message
-from .widgets import StreamingMessage, UserMessage
-
-if TYPE_CHECKING:
-    from padwan_llm import LLMClientBase
-
-chat_group = CommandGroup(name="chat", help="Chat with an LLM")
-
-# Persistent conversation sessions keyed by model name
-_sessions: dict[str, tuple[LLMClientBase, Conversation]] = {}
-
-
-def _get_or_create_session(
-    model: str,
-    system: str | None = None,
-) -> tuple[LLMClientBase, Conversation]:
-    """Get existing session or create a new one for the given model."""
-    if model in _sessions:
-        client, conv = _sessions[model]
-        # Update system prompt if provided and different
-        if system and conv.system != system:
-            conv.system = system
-            # Rebuild messages with new system prompt
-            old_messages = [m for m in conv.messages if m["role"] != "system"]
-            conv.messages = []
-            if system:
-                conv.messages.append(Message(role="system", content=system))
-            conv.messages.extend(old_messages)
-        return client, conv
-
-    client = LLMClient(model=model)
-    conv = Conversation(client, system=system)
-    _sessions[model] = (client, conv)
-    return client, conv
-
-
-CHAT_PROMPT = PromptStyle(text="You: ", css_class="chat-mode")
-
-
-def _format_tokens(conv: Conversation, ctx: TuiContext | None = None) -> str:
-    """Format token usage for display."""
-    if not conv.last_usage:
-        return ""
-    last = conv.last_usage
-    total = conv.total_usage
-    parts = [f"in: {last['input']}", f"out: {last['output']}"]
-    if "cached" in last:
-        parts.append(f"cached: {last['cached']}")
-    parts.append(f"| session: {total['total']}")
-    if ctx and ctx.pending_count > 0:
-        parts.append(f"| {ctx.pending_count} queued")
-    return " ".join(parts)
-
-
-@chat_group.command("send", help="Send a message to the LLM")
-async def chat_send_fn(
-    message: str = Option(..., help="Message to send"),
-    model: str = Option(
-        "gpt-4o-mini", "-m", "--model", help="Model to use", choices=ALL_MODELS
-    ),
-    ctx: TuiContext = TuiOption(),
-) -> None:
-    """Start a conversation. Use Ctrl+C to exit."""
-    try:
-        client, conv = _get_or_create_session(model)
-    except Exception as e:
-        console.print(f"[red]Error creating session for {model}: {e}[/red]")
-        return
-
-    async with client:
-        user_input: str | None = message
-        original_style = ctx.set_prompt_style(CHAT_PROMPT)
-        ctx.set_hint("Chat mode - press Ctrl+C to exit")
-        ctx.set_rule_above(add_class="chat-mode")
-        ctx.set_rule_below(add_class="chat-mode")
-
-        try:
-            while user_input:
-                if ctx.is_tui:
-                    ctx.mount_widget(UserMessage(user_input))
-                    widget = StreamingMessage()
-                    ctx.mount_widget(widget)
-                    ctx.set_hint("Responding...")
-                    ctx.set_silent_queue(True)
-                    async for chunk in conv.stream(user_input):
-                        widget.append(chunk)
-                        if (n := ctx.pending_count) > 0:
-                            ctx.set_hint(f"Responding... ({n} queued)")
-                    ctx.set_silent_queue(False)
-                    ctx.set_hint("Chat mode - press Ctrl+C to exit")
-                    ctx.set_status_above(_format_tokens(conv, ctx) or None)
-                    user_input = await ctx.prompt()
-                else:
-                    async for chunk in conv.stream(user_input):
-                        console.print(chunk, end="")
-                    console.print()
-                    if tokens := _format_tokens(conv):
-                        console.print(f"[dim]{tokens}[/dim]")
-                    break
-        finally:
-            ctx.set_silent_queue(False)
-            ctx.clear_queue()  # Discard any messages typed during streaming
-            ctx.set_status_above(None)
-            ctx.set_hint(None)
-            ctx.set_rule_above(remove_class="chat-mode")
-            ctx.set_rule_below(remove_class="chat-mode")
-            if original_style:
-                ctx.set_prompt_style(original_style)
-
-
-@chat_group.command("clear", help="Clear conversation history")
-async def chat_clear_fn(
-    model: str | None = Option(
-        None,
-        "-m",
-        "--model",
-        help="Model session to clear (all if omitted)",
-        choices=ALL_MODELS,
-    ),
-    ctx: TuiContext = TuiOption(),
-) -> None:
-    """Clear conversation history for a model or all models."""
-    if model:
-        if model in _sessions:
-            _sessions[model][1].clear()
-            ctx.notify(f"Cleared history for {model}", title="Chat")
-            print(f"Cleared conversation history for {model}")
-        else:
-            print(f"No active session for {model}")
-    else:
-        for _, conv in _sessions.values():
-            conv.clear()
-        ctx.notify("Cleared all chat history", title="Chat")
-        print("Cleared all conversation history")

padwan_cli-0.2.2/padwan_cli/conversation.py

@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncIterator
-from dataclasses import dataclass, field
-
-from padwan_llm._base import LLMClientBase
-from padwan_llm.conversation import ConversationState, Message
-from padwan_llm.models import UsageToken
-
-__all__ = ("Conversation", "Message")
-
-
-@dataclass
-class Conversation:
-    """Manages a multi-turn conversation with an LLM client.
-
-    The Conversation class wraps ConversationState and provides streaming
-    interface for chat interactions. Provider-specific details are handled
-    by the client's stream_chat method.
-
-    Example:
-        async with LLMClient(model="gpt-4o") as client:
-            conv = Conversation(client, system="You are a helpful assistant.")
-            async for chunk in conv.stream("Hello!"):
-                print(chunk, end="", flush=True)
-    """
-
-    client: LLMClientBase
-    system: str | None = None
-    _state: ConversationState = field(init=False)
-
-    def __post_init__(self) -> None:
-        self._state = ConversationState(system=self.system)
-
-    @property
-    def messages(self) -> list[Message]:
-        """Access the conversation message history."""
-        return self._state.messages
-
-    @messages.setter
-    def messages(self, value: list[Message]) -> None:
-        """Set the conversation message history."""
-        self._state.messages = value
-
-    @property
-    def last_usage(self) -> UsageToken | None:
-        """Token usage from the last request."""
-        return self._state.last_usage
-
-    @property
-    def total_usage(self) -> UsageToken:
-        """Cumulative token usage across all requests."""
-        return self._state.total_usage
-
-    def add_user_message(self, content: str) -> Message:
-        """Add a user message to the conversation history."""
-        return self._state.add_user_message(content)
-
-    def add_assistant_message(self, content: str) -> Message:
-        """Add an assistant message to the conversation history."""
-        return self._state.add_assistant_message(content)
-
-    def clear(self) -> None:
-        """Clear conversation history, keeping only the system message if set."""
-        self._state.clear()
-
-    async def stream(self, user_input: str) -> AsyncIterator[str]:
-        """Send a user message and stream the assistant's response.
-
-        Adds the user message to history, streams the response via the client's
-        stream_chat method, yields text as it arrives, and saves the complete
-        response to history when done. Also tracks token usage.
-        """
-        self.add_user_message(user_input)
-
-        response_chunks: list[str] = []
-        chat_stream = self.client.stream_chat(list(self.messages))
-
-        async for text in chat_stream:
-            response_chunks.append(text)
-            yield text
-
-        if chat_stream.usage:
-            self._state.accumulate_usage(chat_stream.usage)
-
-        full_response = "".join(response_chunks)
-        self.add_assistant_message(full_response)
-
-    async def send(self, user_input: str) -> str:
-        """Send a user message and return the complete response (non-streaming)."""
-        chunks = []
-        async for chunk in self.stream(user_input):
-            chunks.append(chunk)
-        return "".join(chunks)