1745e03550
sync_from_agent reads directly from agent entries, so remove: - UserInput (pending input shown from MindState.input) - ToolCall, ToolResult (shown from entries on completion) - ToolStarted, ToolFinished (replaced by shared active_tools) - replay_session_to_ui (sync_from_agent handles replay) -139 lines. Remaining variants are streaming (TextDelta, Reasoning), status bar state, or ephemeral UI messages (Info, Debug). Co-Authored-By: Proof of Concept <poc@bcachefs.org>
133 lines
4.4 KiB
Rust
133 lines
4.4 KiB
Rust
// ui_channel.rs — Output routing for TUI panes
|
|
//
|
|
// All output from the agent (streaming text, tool calls, status updates)
|
|
// goes through a UiMessage enum sent over an mpsc channel. The TUI
|
|
// receives these messages and routes them to the appropriate pane.
|
|
//
|
|
// This replaces direct stdout/stderr printing throughout the codebase.
|
|
// The agent and API client never touch the terminal directly — they
|
|
// just send messages that the TUI renders where appropriate.
|
|
//
|
|
// The channel also fans out to a broadcast channel so the observation
|
|
// socket (observe.rs) can subscribe without touching the main path.
|
|
|
|
use std::sync::Arc;
|
|
use tokio::sync::{broadcast, mpsc};
|
|
|
|
// Re-export context types that moved to agent::context
|
|
pub use crate::agent::context::{ContextSection, SharedContextState, shared_context_state};
|
|
|
|
// ActiveToolCall lives in agent::tools — re-export for TUI access
|
|
pub use crate::agent::tools::ActiveToolCall;
|
|
|
|
/// Shared active tool calls — agent spawns, TUI reads metadata / aborts.
|
|
pub type SharedActiveTools = Arc<std::sync::Mutex<Vec<ActiveToolCall>>>;
|
|
|
|
pub fn shared_active_tools() -> SharedActiveTools {
|
|
Arc::new(std::sync::Mutex::new(Vec::new()))
|
|
}
|
|
|
|
/// Which pane streaming text should go to.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum StreamTarget {
|
|
/// User-initiated turn — text goes to conversation pane.
|
|
Conversation,
|
|
/// DMN-initiated turn — text goes to autonomous pane.
|
|
Autonomous,
|
|
}
|
|
|
|
/// Status info for the bottom status bar.
|
|
#[derive(Debug, Clone)]
|
|
#[allow(dead_code)]
|
|
pub struct StatusInfo {
|
|
pub dmn_state: String,
|
|
pub dmn_turns: u32,
|
|
pub dmn_max_turns: u32,
|
|
pub prompt_tokens: u32,
|
|
pub completion_tokens: u32,
|
|
pub model: String,
|
|
/// Number of tool calls dispatched in the current turn.
|
|
pub turn_tools: u32,
|
|
/// Context window budget breakdown (e.g. "id:8% mem:25% jnl:30% conv:37%").
|
|
pub context_budget: String,
|
|
}
|
|
|
|
/// Context loading details for the debug screen.
|
|
#[derive(Debug, Clone)]
|
|
pub struct ContextInfo {
|
|
pub model: String,
|
|
pub available_models: Vec<String>,
|
|
pub prompt_file: String,
|
|
pub backend: String,
|
|
#[allow(dead_code)]
|
|
pub instruction_files: Vec<(String, usize)>,
|
|
#[allow(dead_code)]
|
|
pub memory_files: Vec<(String, usize)>,
|
|
pub system_prompt_chars: usize,
|
|
pub context_message_chars: usize,
|
|
}
|
|
|
|
/// Messages sent from agent/API to the TUI for rendering.
|
|
#[derive(Debug, Clone)]
|
|
#[allow(dead_code)]
|
|
pub enum UiMessage {
|
|
/// Streaming text delta — routed to conversation or autonomous pane.
|
|
TextDelta(String, StreamTarget),
|
|
|
|
/// DMN state annotation: [dmn: foraging (3/20)].
|
|
DmnAnnotation(String),
|
|
|
|
/// Status bar update.
|
|
StatusUpdate(StatusInfo),
|
|
|
|
/// Live activity indicator for the status bar.
|
|
Activity(String),
|
|
|
|
/// Reasoning/thinking tokens from the model (internal monologue).
|
|
Reasoning(String),
|
|
|
|
/// Debug message (only shown when POC_DEBUG is set).
|
|
Debug(String),
|
|
|
|
/// Informational message — goes to conversation pane (command output, etc).
|
|
Info(String),
|
|
|
|
/// Context loading details — stored for the debug screen.
|
|
ContextInfoUpdate(ContextInfo),
|
|
|
|
/// Agent cycle state update — refreshes the F2 agents screen.
|
|
AgentUpdate(Vec<crate::subconscious::subconscious::AgentSnapshot>),
|
|
}
|
|
|
|
/// Sender that fans out to both the TUI (mpsc) and observers (broadcast).
|
|
#[derive(Clone)]
|
|
pub struct UiSender {
|
|
tui: mpsc::UnboundedSender<UiMessage>,
|
|
observe: broadcast::Sender<UiMessage>,
|
|
}
|
|
|
|
impl UiSender {
|
|
pub fn send(&self, msg: UiMessage) -> Result<(), mpsc::error::SendError<UiMessage>> {
|
|
// Broadcast to observers (ignore errors — no subscribers is fine)
|
|
let _ = self.observe.send(msg.clone());
|
|
self.tui.send(msg)
|
|
}
|
|
|
|
/// Subscribe to the broadcast side (for the observation socket).
|
|
pub fn subscribe(&self) -> broadcast::Receiver<UiMessage> {
|
|
self.observe.subscribe()
|
|
}
|
|
}
|
|
|
|
/// Convenience type for the receiving half.
|
|
pub type UiReceiver = mpsc::UnboundedReceiver<UiMessage>;
|
|
|
|
/// Create a new UI channel pair.
|
|
pub fn channel() -> (UiSender, UiReceiver) {
|
|
let (tui_tx, tui_rx) = mpsc::unbounded_channel();
|
|
let (observe_tx, _) = broadcast::channel(1024);
|
|
(UiSender { tui: tui_tx, observe: observe_tx }, tui_rx)
|
|
}
|
|
|
|
/// Replay a restored session into the TUI panes so the user can see
|
|
/// conversation history immediately on restart. Shows user input,
|