padwan-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{padwan_cli-0.4.0 → padwan_cli-0.5.0}/PKG-INFO

@@ -1,11 +1,14 @@
 Metadata-Version: 2.3
 Name: padwan-cli
-Version: 0.4.0
+Version: 0.5.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-Dist: padwan-llm[realtime]>=0.8.0
+Requires-Dist: piou[tui]>=0.36.0
+Requires-Dist: tracktolib>=0.74.0
+Requires-Dist: sounddevice>=0.5 ; extra == 'voice'
 Requires-Python: >=3.14
+Provides-Extra: voice
 Description-Content-Type: text/markdown
 
 # Padwan CLI

{padwan_cli-0.4.0 → padwan_cli-0.5.0}/padwan_cli/chat.py

@@ -1,7 +1,9 @@
 import contextlib
 import json
+import mimetypes
 import time
 from contextlib import contextmanager
+from pathlib import Path
 from typing import Any
 
 from piou import Option, CommandGroup
@@ -10,22 +12,30 @@ from textual.css.query import NoMatches
 
 from padwan_llm import (
     AgentSession,
+    ContentPart,
     ConversationSnapshot,
     LLMClient,
     McpStreamable,
     McpTool,
     McpTransport,
     ToolCallContext,
+    image_part,
+    supports_vision,
+    text_file_part,
+    text_part,
 )
 from padwan_llm.gemini import GeminiClient
 from padwan_llm.gemini.models import ThinkingConfig
 from .utils import ALL_MODELS, console
 from .widgets import (
+    Attachment,
+    AttachmentBadge,
     ErrorMessage,
     StreamingMessage,
     ThoughtMessage,
     ToolCallMessage,
     UserMessage,
+    render_attachments,
 )
 
 chat_group = CommandGroup(name="chat", help="Chat with an LLM")
@@ -85,6 +95,48 @@ def _format_tokens(session: AgentSession, ctx: TuiContext | None = None) -> str:
     return " ".join(parts)
 
 
+def _build_user_content(
+    text: str, attachments: list[Attachment]
+) -> str | list[ContentPart]:
+    """Assemble the user turn from typed text and queued attachments.
+
+    Returns the plain string when nothing is attached. Otherwise builds content
+    parts: the text, each text file inlined, and each supported image as a data
+    URL. Unsupported images (text-only model) and unreadable files are dropped
+    from the payload — they still appear in the sent badge.
+    """
+    if not attachments:
+        return text
+    parts: list[ContentPart] = []
+    if text:
+        parts.append(text_part(text))
+    for a in attachments:
+        if a.is_image:
+            if a.supported:
+                parts.append(image_part(a.path))
+        else:
+            try:
+                parts.append(text_file_part(a.path))
+            except OSError, UnicodeDecodeError:
+                continue
+    return parts
+
+
+def _parse_extra_params(raw: str | None) -> tuple[dict[str, Any] | None, bool]:
+    """Parse --extra-params JSON; print the error and return ok=False on failure."""
+    if raw is None:
+        return None, True
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError as e:
+        console.print(f"[red]--extra-params is not valid JSON: {e}[/red]")
+        return None, False
+    if not isinstance(parsed, dict):
+        console.print("[red]--extra-params must be a JSON object[/red]")
+        return None, False
+    return parsed, True
+
+
 @chat_group.command("send", help="Send a message to the LLM")
 async def chat_send_fn(
     message: str = Option(..., help="Message to send"),
@@ -158,16 +210,9 @@ async def chat_send_fn(
         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
+    parsed_extra, ok = _parse_extra_params(extra_params)
+    if not ok:
+        return
 
     try:
         client = LLMClient(model=model, on_thought=_on_thought, base_url=base_url)
@@ -196,16 +241,84 @@ async def chat_send_fn(
             ctx.set_rule_above(add_class="chat-mode")
             ctx.set_rule_below(add_class="chat-mode")
 
+            # Files dropped onto the terminal arrive as a paste of their path(s);
+            # queue them here and send with the next typed message.
+            pending: list[Attachment] = []
+
+            def _set_attach_warning(on: bool) -> None:
+                """Turn the input bars amber (or back to chat-mode cyan)."""
+                add, remove = (
+                    ("attach-warning", "chat-mode")
+                    if on
+                    else ("chat-mode", "attach-warning")
+                )
+                ctx.set_rule_above(add_class=add, remove_class=remove)
+                ctx.set_rule_below(add_class=add, remove_class=remove)
+
+            def _on_drop(paths: list[Path]) -> None:
+                for p in paths:
+                    try:
+                        size = p.stat().st_size
+                    except OSError:
+                        continue
+                    is_image = (mimetypes.guess_type(p)[0] or "").startswith("image/")
+                    pending.append(
+                        Attachment(
+                            path=p,
+                            name=p.name,
+                            size=size,
+                            is_image=is_image,
+                            supported=(not is_image) or supports_vision(model),
+                        )
+                    )
+                blind = [a for a in pending if a.is_image and not a.supported]
+                warning = (
+                    f"{model} can't read images — {len(blind)} will be skipped"
+                    if blind
+                    else None
+                )
+                ctx.set_attachments(render_attachments(pending, warning=warning))
+                _set_attach_warning(bool(blind))
+                ctx.set_hint(
+                    f"{len(pending)} attached — type a message · Ctrl+U clears"
+                )
+
+            def _on_clear() -> None:
+                pending.clear()
+                ctx.set_attachments(None)
+                _set_attach_warning(False)
+                ctx.set_hint("Chat mode - press Ctrl+C to exit")
+
+            ctx.register_paste_handler(_on_drop)
+            ctx.register_attachment_clear(_on_clear)
+
             try:
                 while user_input:
                     if ctx.is_tui:
+                        sent = list(pending)
                         ctx.mount_widget(UserMessage(user_input))
+                        if sent:
+                            skipped = [
+                                a for a in sent if a.is_image and not a.supported
+                            ]
+                            badge_warning = (
+                                f"{model} can't read images — {len(skipped)} skipped"
+                                if skipped
+                                else None
+                            )
+                            ctx.mount_widget(
+                                AttachmentBadge(sent, warning=badge_warning)
+                            )
+                        content = _build_user_content(user_input, sent)
+                        pending.clear()
+                        ctx.set_attachments(None)
+                        _set_attach_warning(False)
                         ctx.set_hint("Responding...")
                         ctx.set_silent_queue(True)
                         needs_new_text_widget = True
                         widget: StreamingMessage | None = None
                         try:
-                            async for chunk in session.stream(user_input):
+                            async for chunk in session.stream(content):
                                 if needs_new_text_widget or widget is None:
                                     widget = StreamingMessage()
                                     ctx.mount_widget(widget)
@@ -237,6 +350,8 @@ async def chat_send_fn(
                         break
             finally:
                 session.save()
+                ctx.register_paste_handler(None)
+                ctx.register_attachment_clear(None)
                 # 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
@@ -245,9 +360,12 @@ async def chat_send_fn(
                     ctx.set_silent_queue(False)
                     ctx.clear_queue()  # Discard any messages typed during streaming
                     ctx.set_status_above(None)
+                    ctx.set_attachments(None)
                     ctx.set_hint(None)
                     ctx.set_rule_above(remove_class="chat-mode")
                     ctx.set_rule_below(remove_class="chat-mode")
+                    ctx.set_rule_above(remove_class="attach-warning")
+                    ctx.set_rule_below(remove_class="attach-warning")
                     if original_style:
                         ctx.set_prompt_style(original_style)
     except Exception as e:

{padwan_cli-0.4.0 → padwan_cli-0.5.0}/padwan_cli/run.py

@@ -23,11 +23,15 @@ from padwan_llm.errors import Provider
 from .utils import console
 from .batch import batch_group
 from .chat import chat_group
+from .talk import talk_command
 
 CUSTOM_CSS = """
 Rule.chat-mode {
     color: #87ceeb;
 }
+Rule.attach-warning {
+    color: #fbbf24;
+}
 """
 
 cli = Cli(description="Padwan CLI for the unified LLM client library")
@@ -35,6 +39,8 @@ cli = Cli(description="Padwan CLI for the unified LLM client library")
 cli.add_command_group(batch_group)
 cli.add_command_group(chat_group)
 
+cli.command("talk", help="Speech-to-speech voice chat")(talk_command)
+
 
 @cli.tui_on_ready
 def _tui_startup_hint() -> None:

padwan_cli-0.5.0/padwan_cli/talk.py

@@ -0,0 +1,401 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import functools
+import os
+import queue
+import signal
+import sys
+import termios
+import threading
+import tty
+
+from piou import Option
+from piou.tui import get_tui_context
+from tracktolib.utils import BytesBuffer
+
+from padwan_llm import RealtimeClient, RealtimeConnection, RealtimeServerEvent
+from padwan_llm.errors import LLMError
+from padwan_llm.openai.realtime import NO_TURN_DETECTION, REALTIME_SAMPLE_RATE
+
+from .utils import console
+
+SR = REALTIME_SAMPLE_RATE  # 24 kHz mono PCM16, as gpt-realtime expects
+CHANNELS = 1
+DTYPE = "int16"
+BLOCK = 1200  # 50 ms frames
+
+# Terminals report no key-release: a held Space arrives as auto-repeated spaces.
+# A gap longer than the keyboard's initial repeat delay (~0.66 s default) means
+# the key was released; shorter turns are discarded as accidental taps.
+_HOLD_RELEASE_GAP = 0.8
+_MIN_TURN_SECS = 0.45
+
+_DEFAULT_INSTRUCTIONS = """You are a friendly voice assistant.
+Keep spoken replies brief and conversational — one or two sentences — so the
+exchange stays a real back-and-forth."""
+
+
+class Speaker:
+    """Buffered PCM16 playback with barge-in support.
+
+    BytesBuffer keeps the audio callback O(read size): appends are reference-
+    only and reads copy at chunk boundaries, instead of memmoving the whole
+    queued backlog on every 50 ms tick.
+    """
+
+    def __init__(self, sd) -> None:
+        self._buf = BytesBuffer()
+        self._lock = threading.Lock()
+        self.stream = sd.RawOutputStream(
+            samplerate=SR,
+            channels=CHANNELS,
+            dtype=DTYPE,
+            blocksize=BLOCK,
+            callback=self._callback,
+        )
+
+    def _callback(self, outdata, frames, _time, _status) -> None:  # PortAudio thread
+        need = frames * CHANNELS * 2
+        with self._lock:
+            take = self._buf.get(need) if len(self._buf) else b""
+        if len(take) < need:
+            take += b"\x00" * (need - len(take))  # underflow -> silence
+        outdata[:] = take
+
+    def play(self, pcm16: bytes) -> None:
+        with self._lock:
+            self._buf.put(pcm16)
+
+    def clear(self) -> None:
+        with self._lock:
+            self._buf = BytesBuffer()
+
+
+def _import_sounddevice():
+    """Import sounddevice lazily, with a friendly hint if the extra is missing."""
+    try:
+        import sounddevice as sd
+    except OSError as e:  # PortAudio shared library not found
+        console.print(f"[red]PortAudio unavailable: {e}[/red]")
+        console.print(
+            "[dim]Install the system library, e.g. `apt install libportaudio2`.[/dim]"
+        )
+        raise SystemExit(1)
+    except ImportError:
+        console.print("[red]sounddevice not installed.[/red]")
+        console.print("[dim]Install the voice extra: `uv sync --extra voice`.[/dim]")
+        raise SystemExit(1)
+    return sd
+
+
+@contextlib.contextmanager
+def _cbreak(fd: int):
+    """Put the terminal in cbreak mode so single keypresses arrive immediately."""
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)  # leaves ISIG on, so Ctrl-C still quits
+        yield
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+async def _handle_events(
+    conn: RealtimeConnection, speaker: Speaker, *, push_to_talk: bool
+) -> None:
+    """Consume server events: play audio, stream transcripts, prompt for the turn.
+
+    Your own transcript arrives asynchronously and usually after the assistant has
+    started answering, so assistant text is held until the "you:" line has printed
+    (flushed unconditionally on response.done so nothing is ever lost).
+    """
+    speaking = False  # is the assistant mid-utterance on this line?
+    held: list[str] = []  # assistant transcript held until the "you:" line prints
+    user_shown = True  # has the current turn's input transcript been printed?
+    prepaid = False  # input transcript arrived before its response was created
+
+    def flush_held() -> None:
+        nonlocal speaking
+        if held:
+            console.print("[cyan]assistant:[/cyan] ", end="")
+            sys.stdout.write("".join(held))
+            sys.stdout.flush()
+            held.clear()
+            speaking = True
+
+    async for event in conn:
+        kind = event.get("type")
+        if kind == RealtimeServerEvent.AUDIO_DELTA:
+            if pcm := conn.audio_delta_bytes(event):
+                speaker.play(pcm)
+        elif kind == RealtimeServerEvent.AUDIO_TRANSCRIPT_DELTA:
+            delta = event.get("delta", "")
+            if not user_shown:
+                held.append(delta)
+                continue
+            if not speaking:
+                console.print("[cyan]assistant:[/cyan] ", end="")
+                speaking = True
+            sys.stdout.write(delta)
+            sys.stdout.flush()
+        elif kind == RealtimeServerEvent.RESPONSE_CREATED:
+            if prepaid:
+                prepaid = False  # transcript already printed for this turn
+            else:
+                user_shown = False
+        elif kind == RealtimeServerEvent.SPEECH_STARTED:  # hands-free VAD only
+            speaker.clear()  # barge-in: drop queued assistant audio
+            flush_held()
+            if speaking:
+                sys.stdout.write("\n")
+                speaking = False
+        elif kind == RealtimeServerEvent.INPUT_TRANSCRIPT_COMPLETED:
+            text = (event.get("transcript") or "").strip()
+            if speaking:
+                sys.stdout.write("\n")
+                speaking = False
+            if text:
+                console.print(f"[green]you:[/green] {text}")
+            if user_shown:
+                prepaid = True  # transcript beat its response.created
+            else:
+                user_shown = True
+                flush_held()
+        elif kind == RealtimeServerEvent.RESPONSE_DONE:
+            flush_held()  # transcript never arrived; don't lose the assistant text
+            user_shown = True
+            if speaking:
+                sys.stdout.write("\n")
+                speaking = False
+            if push_to_talk:
+                console.print("[dim]· hold Space to talk[/dim]")
+        elif kind == RealtimeServerEvent.ERROR:
+            console.print(f"\n[dim][error] {event.get('error')}[/dim]")
+
+
+async def _converse(
+    conn: RealtimeConnection, sd, speaker: Speaker, *, push_to_talk: bool
+) -> None:
+    """Pump mic → model and run the event loop, in push-to-talk or hands-free mode."""
+    loop = asyncio.get_running_loop()
+    mic_q: queue.Queue[bytes] = queue.Queue()
+    recording = threading.Event()
+    if not push_to_talk:
+        recording.set()  # hands-free: stream continuously, server VAD picks turns
+
+    def mic_callback(indata, _frames, _time, _status) -> None:  # PortAudio thread
+        if recording.is_set():
+            mic_q.put(bytes(indata))
+
+    mic = sd.RawInputStream(
+        samplerate=SR,
+        channels=CHANNELS,
+        dtype=DTYPE,
+        blocksize=BLOCK,
+        callback=mic_callback,
+    )
+
+    draining = False
+    sent_bytes = 0
+
+    async def pump_mic() -> None:
+        nonlocal draining, sent_bytes
+        # Timed get so the executor thread exits shortly after cancellation
+        # instead of blocking threading shutdown at exit.
+        blocking_get = functools.partial(mic_q.get, True, 0.25)
+        while True:
+            try:
+                chunk = await loop.run_in_executor(None, blocking_get)
+            except queue.Empty:
+                continue
+            # The transport lets roughly one send through per read-poll tick,
+            # so batch everything captured while we waited for the socket.
+            parts = [chunk]
+            while True:
+                try:
+                    parts.append(mic_q.get_nowait())
+                except queue.Empty:
+                    break
+            draining = True
+            try:
+                joined = b"".join(parts)
+                await conn.append_audio(joined)
+                sent_bytes += len(joined)
+            finally:
+                draining = False
+
+    turn_task: asyncio.Task | None = None
+    last_space = 0.0
+    turn_started_at = 0.0
+
+    async def start_turn() -> None:
+        nonlocal turn_started_at, sent_bytes
+        with mic_q.mutex:
+            mic_q.queue.clear()  # drop audio captured before the press
+        speaker.clear()  # stop the assistant if it was still talking
+        await conn.send_event({"type": "input_audio_buffer.clear"})
+        recording.set()
+        turn_started_at = loop.time()
+        sent_bytes = 0
+        console.print("[red]● recording…[/red] [dim]release Space to send[/dim]")
+
+    async def end_turn() -> None:
+        recording.clear()
+        # Wait until everything captured actually reached the socket, so the
+        # commit doesn't clip the tail of the turn.
+        deadline = loop.time() + 3
+        while (not mic_q.empty() or draining) and loop.time() < deadline:
+            await asyncio.sleep(0.05)
+        if loop.time() - turn_started_at < _MIN_TURN_SECS:
+            await conn.send_event({"type": "input_audio_buffer.clear"})
+            console.print("[dim](too short — hold Space while speaking)[/dim]")
+            return
+        await conn.commit_audio()
+        await conn.create_response()
+        console.print(f"[dim](sent {sent_bytes / (SR * 2):.1f}s of audio)[/dim]")
+
+    def _spawn_turn(coro_fn) -> None:
+        nonlocal turn_task
+        if turn_task is not None and not turn_task.done():
+            return  # previous transition still in flight
+        turn_task = asyncio.create_task(coro_fn())
+
+    def on_key() -> None:  # called by the event loop when stdin is readable
+        nonlocal last_space
+        try:
+            data = os.read(sys.stdin.fileno(), 1)
+        except OSError:
+            return
+        if data == b" ":
+            # Held Space shows up as auto-repeated spaces; each one refreshes
+            # the hold. The release watcher ends the turn once they stop.
+            last_space = loop.time()
+            if not recording.is_set():
+                _spawn_turn(start_turn)
+        elif data in (b"\r", b"\n") and recording.is_set():
+            _spawn_turn(end_turn)  # manual send fallback
+
+    async def watch_release() -> None:
+        while True:
+            await asyncio.sleep(0.1)
+            if recording.is_set() and loop.time() - last_space > _HOLD_RELEASE_GAP:
+                _spawn_turn(end_turn)
+
+    use_keys = push_to_talk and sys.stdin.isatty()
+    with mic:
+        sender = asyncio.create_task(pump_mic())
+        watcher = asyncio.create_task(watch_release()) if use_keys else None
+        fd = sys.stdin.fileno()
+        try:
+            if use_keys:
+                with _cbreak(fd):
+                    loop.add_reader(fd, on_key)
+                    try:
+                        await _handle_events(conn, speaker, push_to_talk=True)
+                    finally:
+                        loop.remove_reader(fd)
+            else:
+                await _handle_events(conn, speaker, push_to_talk=False)
+        finally:
+            sender.cancel()
+            if watcher is not None:
+                watcher.cancel()
+            if turn_task is not None:
+                turn_task.cancel()
+
+
+async def talk_command(
+    voice: str = Option("marin", "--voice", help="Realtime voice (marin, cedar, …)"),
+    model: str = Option("gpt-realtime", "-m", "--model", help="Realtime model"),
+    instructions: str | None = Option(
+        None, "--instructions", help="System prompt for the voice assistant"
+    ),
+    hands_free: bool = Option(
+        False, "--hands-free", help="Auto voice detection instead of push-to-talk"
+    ),
+    check: bool = Option(
+        False, "--check", help="List audio devices and key status, then exit"
+    ),
+) -> None:
+    """Talk with a real-time voice assistant (speech-to-speech)."""
+    # A live mic/speaker session needs the whole terminal; the Textual TUI owns it,
+    # so this command only works headless. Fail loudly instead of hanging silently.
+    if get_tui_context().is_tui:
+        console.print(
+            "[yellow]`talk` is a full-terminal voice session and can't run inside "
+            "the TUI.[/yellow]\n[dim]Run it headless:[/dim] [bold]uv run padwan-talk"
+            "[/bold] [dim](or `python -m padwan_cli talk`).[/dim]"
+        )
+        return
+
+    sd = _import_sounddevice()
+
+    if check:
+        console.print(sd.query_devices())
+        console.print(f"\nDefault (input, output): {sd.default.device}")
+        try:
+            RealtimeClient(model=model)
+            key_status = "found"
+        except LLMError:
+            key_status = "[red]MISSING[/red]"
+        console.print(f"OPENAI_API_KEY: {key_status}")
+        console.print(f"model={model}  voice={voice}")
+        return
+
+    push_to_talk = not hands_free
+    if push_to_talk and not sys.stdin.isatty():
+        console.print(
+            "[yellow]push-to-talk needs a terminal; using --hands-free.[/yellow]"
+        )
+        push_to_talk = False
+
+    prompt = instructions or _DEFAULT_INSTRUCTIONS
+    # Push-to-talk disables server VAD so we commit each turn ourselves.
+    turn_detection = NO_TURN_DETECTION if push_to_talk else None
+    # The client validates the API key itself (LLMError when unset).
+    try:
+        client = RealtimeClient(
+            model=model,
+            instructions=prompt,
+            voice=voice,
+            turn_detection=turn_detection,
+        )
+    except LLMError as e:
+        console.print(f"[red]{e}[/red] [dim]— export it or add it to .env[/dim]")
+        return
+    speaker = Speaker(sd)
+    console.print(f"[dim]connecting to {model} (voice: {voice})…[/dim]")
+    # Route Ctrl-C through task cancellation: a raw KeyboardInterrupt tears the
+    # loop down without unwinding the session/mic/speaker, leaking pending tasks.
+    loop = asyncio.get_running_loop()
+    task = asyncio.current_task()
+    if task is not None:
+        loop.add_signal_handler(signal.SIGINT, task.cancel)
+    try:
+        async with client as conn:
+            with speaker.stream:
+                if push_to_talk:
+                    console.print(
+                        "[green]Ready.[/green] [dim]Hold Space while talking, "
+                        "release to send. Ctrl-C to quit.[/dim]\n"
+                    )
+                else:
+                    console.print(
+                        "[green]Go ahead.[/green] [dim](hands-free — just speak. "
+                        "Ctrl-C to quit.)[/dim]\n"
+                    )
+                await _converse(conn, sd, speaker, push_to_talk=push_to_talk)
+    except asyncio.CancelledError:
+        console.print("\n[dim]Bye! 👋[/dim]")
+    finally:
+        if task is not None:
+            loop.remove_signal_handler(signal.SIGINT)
+
+
+def main() -> None:
+    """Headless entry point (`padwan-talk`): run the voice chat without the TUI."""
+    # Deferred import avoids a circular import (run imports talk at module load).
+    from .run import cli
+
+    cli.run_with_args("talk", *sys.argv[1:])

{padwan_cli-0.4.0 → padwan_cli-0.5.0}/padwan_cli/widgets.py

@@ -1,8 +1,14 @@
 from __future__ import annotations
 
 import json
+from dataclasses import dataclass
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
+from rich import box
+from rich.columns import Columns
+from rich.console import Group, RenderableType
+from rich.panel import Panel
 from rich.text import Text
 from textual.widgets import Static
 
@@ -17,6 +23,75 @@ ASSISTANT_COLOR = "#98fb98"
 TOOL_CALL_COLOR = "#ffa500"
 THOUGHT_COLOR = "#9370db"
 ERROR_COLOR = "#ff6b6b"
+ATTACHMENT_COLOR = USER_COLOR
+WARN_COLOR = "#fbbf24"
+CHIP_BG = "#1f2230"
+CHIP_BORDER = "#3a3f55"
+
+
+@dataclass
+class Attachment:
+    """A file dropped into the chat, queued to send with the next message."""
+
+    path: Path
+    name: str
+    size: int
+    is_image: bool
+    supported: bool  # whether the active model can use it (images need vision)
+
+
+def human_size(num_bytes: int) -> str:
+    """Format a byte count as a short human-readable string."""
+    size = float(num_bytes)
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024 or unit == "GB":
+            return f"{int(size)} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} GB"
+
+
+def _chip_panel(a: Attachment) -> Panel:
+    """Build one bordered pill chip for an attachment.
+
+    Unsupported files get an amber border (the "which"); the reason — a
+    model-level fact — is carried once by the warning bar and hint.
+    """
+    label = Text()
+    label.append(f"📎 {a.name}", style=ATTACHMENT_COLOR)
+    label.append(f"  {human_size(a.size)}", style="dim")
+    return Panel(
+        label,
+        box=box.ROUNDED,
+        border_style=WARN_COLOR if not a.supported else CHIP_BORDER,
+        style=f"on {CHIP_BG}",
+        padding=(0, 1),
+        expand=False,
+    )
+
+
+def render_chips(attachments: list[Attachment]) -> Columns:
+    """Render queued attachments as a row of bordered pill chips."""
+    return Columns([_chip_panel(a) for a in attachments], padding=(0, 1), expand=False)
+
+
+def render_attachments(
+    attachments: list[Attachment], *, warning: str | None = None
+) -> RenderableType:
+    """Render the attachment block: an optional amber warning line, then chips."""
+    chips = render_chips(attachments)
+    if warning:
+        return Group(Text(f"⚠ {warning}", style=WARN_COLOR), chips)
+    return chips
+
+
+class AttachmentBadge(Static):
+    """Bordered pill chips shown under a sent user message."""
+
+    def __init__(
+        self, attachments: list[Attachment], *, warning: str | None = None, **kwargs
+    ) -> None:
+        super().__init__(render_attachments(attachments, warning=warning), **kwargs)
+
 
 # Colors for batch job states
 STATE_COLORS = {

padwan_cli-0.5.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "padwan-cli"
+version = "0.5.0"
+description = "CLI and TUI for padwan-llm"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "padwan-llm[realtime]>=0.8.0",
+    "piou[tui]>=0.36.0",
+    "tracktolib>=0.74.0",
+]
+
+[[project.authors]]
+email = "julien.brayere@polarsen.com"
+
+[project.optional-dependencies]
+voice = ["sounddevice>=0.5"]
+
+[project.scripts]
+padwan-cli = "padwan_cli:main_tui"
+padwan-talk = "padwan_cli.talk:main"
+
+[build-system]
+requires = ["uv_build>=0.9.28,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+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"
+
+[dependency-groups]
+dev = [
+    "piou[tui-reload]>=0.36.0",
+    "pyright>=1.1.408",
+    "pytest>=8.0.0",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.11.0",
+]
+docs = ["zensical>=0.0.31"]
+bump = ["commitizen>=4.0.0"]

padwan_cli-0.4.0/pyproject.toml → padwan_cli-0.5.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "padwan-cli"
-version = "0.4.0"
+version = "0.5.0"
 description = "CLI and TUI for padwan-llm"
 readme = "README.md"
 authors = [
@@ -8,12 +8,18 @@ authors = [
 ]
 requires-python = ">=3.14"
 dependencies = [
-    "padwan-llm>=0.6.0",
-    "piou[tui]>=0.34.1",
+    "padwan-llm[realtime]>=0.8.0",
+    "piou[tui]>=0.36.0",
+    "tracktolib>=0.74.0",
 ]
 
+[project.optional-dependencies]
+# `talk` command audio I/O; also needs the PortAudio system lib (libportaudio2).
+voice = ["sounddevice>=0.5"]
+
 [project.scripts]
 padwan-cli = "padwan_cli:main_tui"
+padwan-talk = "padwan_cli.talk:main"
 
 [build-system]
 requires = ["uv_build>=0.9.28,<0.10.0"]
@@ -22,12 +28,9 @@ build-backend = "uv_build"
 [tool.uv.build-backend]
 module-root = ""
 
-#[tool.uv.sources]
-#padwan-llm = { path = "../padwan-llm", editable = true }
-
 [dependency-groups]
 dev = [
-    "piou[tui-reload]>=0.33.0",
+    "piou[tui-reload]>=0.36.0",
     "pyright>=1.1.408",
     "pytest>=8.0.0",
     "pytest-asyncio>=1.3.0",