rho-coding-agent 2.13.0

use std::{collections::BTreeMap, path::PathBuf};

use rho_sdk::{
    model::ToolCall,
    tool::{ToolAsset, ToolMetadata, ToolProgress},
    ToolCallId, ToolCompletion,
};

use rho_tools::tool_card::ToolCard;

#[path = "interactive_presenter_agent.rs"]
mod agent_format;
#[path = "interactive_presenter_format.rs"]
mod format;
#[path = "interactive_presenter_message.rs"]
mod message_format;
#[path = "interactive_presenter_sessions.rs"]
mod sessions_format;
use format::*;

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct ToolPresentation {
    pub(crate) card: ToolCard,
    pub(crate) image_asset: Option<ToolAsset>,
}

pub(crate) struct FinishedToolPresentation {
    pub(crate) presentation: crate::presentation::Presentation,
    pub(crate) image_asset: Option<ToolAsset>,
}

#[derive(Clone, Debug)]
struct ToolView {
    kind: ToolKind,
    name: String,
    arguments: serde_json::Value,
    metadata: ToolMetadata,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ToolKind {
    Advisor,
    Agent,
    Agents,
    Bash,
    PowerShell,
    Process,
    ListDir,
    Grep,
    Glob,
    ReadFile,
    WriteFile,
    Edit(rho_tools::EditFormat),
    Skill,
    WebSearch,
    FetchContent,
    GetSearchContent,
    Questionnaire,
    Sessions,
    Mcp,
    Other,
}

impl ToolKind {
    fn from_name(name: &str) -> Self {
        Self::from_name_and_args(name, None)
    }

    fn from_name_and_args(name: &str, _arguments: Option<&serde_json::Value>) -> Self {
        if let Some(format) = rho_tools::EditFormat::from_tool_name(name) {
            return Self::Edit(format);
        }
        if crate::tools::mcp::exported_name::parse_exported_name(
            name,
            crate::tools::mcp::exported_name::ExportedNameDialect::Rho,
        )
        .is_some()
        {
            return Self::Mcp;
        }
        match name {
            "advisor" => Self::Advisor,
            "agent" => Self::Agent,
            "agents" => Self::Agents,
            "bash" => Self::Bash,
            "powershell" => Self::PowerShell,
            "process" => Self::Process,
            "list_dir" => Self::ListDir,
            "grep" => Self::Grep,
            "glob" => Self::Glob,
            "read_file" => Self::ReadFile,
            "write" => Self::WriteFile,
            "skill" => Self::Skill,
            "web_search" => Self::WebSearch,
            "fetch_content" => Self::FetchContent,
            "get_search_content" => Self::GetSearchContent,
            "questionnaire" => Self::Questionnaire,
            "sessions" => Self::Sessions,
            _ => Self::Other,
        }
    }

    /// How many new argument bytes to wait before re-rendering a live preview.
    ///
    /// Zero re-evaluates on every delta so previews track the model as it
    /// writes; identical renders are still suppressed by `last_card`, so the
    /// stride bounds parse cost rather than update rate. Ordinary tool calls
    /// stay under [`PREVIEW_FULL_PARSE_LIMIT`] and re-render delta for delta.
    /// Oversized buffers, including long agent prompts, fall back to a coarse
    /// stride so parse cost stays linear in argument size.
    fn preview_parse_stride(self, arguments_len: usize) -> usize {
        if matches!(self, Self::Edit(_)) && arguments_len >= EDIT_STREAM_PREVIEW_LIMIT {
            // Grow with buffer size so total parse work stays linear for long
            // streams instead of rescanning on a fixed byte interval.
            return arguments_len.max(EDIT_STREAM_PREVIEW_STRIDE);
        }
        match self {
            Self::Advisor
            | Self::Agent
            | Self::Agents
            | Self::Bash
            | Self::PowerShell
            | Self::Process
            | Self::ListDir
            | Self::Grep
            | Self::Glob
            | Self::ReadFile
            | Self::WriteFile
            | Self::Edit(_)
            | Self::Skill
            | Self::WebSearch
            | Self::FetchContent
            | Self::GetSearchContent
            | Self::Questionnaire
            | Self::Sessions
            | Self::Mcp
            | Self::Other => {
                if arguments_len < PREVIEW_FULL_PARSE_LIMIT {
                    0
                } else {
                    PREVIEW_LARGE_PARSE_STRIDE
                }
            }
        }
    }
}

/// Argument-buffer size above which live previews stop parsing every delta.
///
/// Ordinary tool calls stay far below this and re-render delta for delta. A
/// long `write` body would otherwise re-parse the whole buffer thousands
/// of times, so oversized buffers switch to [`PREVIEW_LARGE_PARSE_STRIDE`].
const PREVIEW_FULL_PARSE_LIMIT: usize = 4096;

/// Argument bytes accumulated between parses past [`PREVIEW_FULL_PARSE_LIMIT`].
const PREVIEW_LARGE_PARSE_STRIDE: usize = 4096;

/// Edit argument size above which streaming previews use a coarse stride.
///
/// The final proposal still parses the complete document once.
const EDIT_STREAM_PREVIEW_LIMIT: usize = 256 * 1024;

/// Minimum bytes between edit preview rebuilds past
/// [`EDIT_STREAM_PREVIEW_LIMIT`]. Actual intervals grow with buffer size.
const EDIT_STREAM_PREVIEW_STRIDE: usize = 64 * 1024;

#[derive(Clone, Debug, Default)]
struct StreamedPreview {
    name: Option<String>,
    arguments: String,
    next_parse_length: usize,
    last_args: Option<serde_json::Value>,
    last_card: Option<ToolCard>,
}

pub(crate) struct InteractiveToolPresenter {
    cwd: PathBuf,
    calls: BTreeMap<String, ToolView>,
    streamed: BTreeMap<usize, StreamedPreview>,
}

impl InteractiveToolPresenter {
    pub(crate) fn new(cwd: PathBuf) -> Self {
        Self {
            cwd,
            calls: BTreeMap::new(),
            streamed: BTreeMap::new(),
        }
    }

    /// Discards streamed previews from the previous model step. Provider
    /// tool-call indexes restart at zero every step, so stale entries would
    /// otherwise absorb the next step's argument deltas.
    pub(crate) fn step_started(&mut self) {
        self.streamed.clear();
    }

    pub(crate) fn preview(
        &mut self,
        index: usize,
        name: Option<String>,
        arguments_delta: &str,
    ) -> Option<ToolPresentation> {
        let preview = self.streamed.entry(index).or_default();
        let name_changed = name
            .as_ref()
            .is_some_and(|name| preview.name.as_ref().is_some_and(|current| current != name));
        if name_changed {
            preview.arguments.clear();
            preview.next_parse_length = 0;
            preview.last_args = None;
            preview.last_card = None;
        }
        if let Some(name) = name {
            preview.name = Some(name);
        }
        preview.arguments.push_str(arguments_delta);
        // A provider commonly announces a call's identity before sending any
        // arguments. Keep accumulating that canonical stream state, but do not
        // render a bare card while there is nothing useful to preview.
        if preview.arguments.is_empty() {
            return None;
        }
        let name = preview.name.as_deref()?;
        if !name_changed && preview.arguments.len() < preview.next_parse_length {
            return None;
        }
        if let Some(args) = parse_incomplete_json(&preview.arguments) {
            preview.last_args = Some(args);
        }
        let kind = ToolKind::from_name_and_args(name, preview.last_args.as_ref());
        let card = match kind {
            // Keep the last successful parse so a mid-stream incomplete fragment
            // does not wipe a useful card back to a bare header.
            ToolKind::Agent => agent_format::agent_streaming_preview_card(
                preview
                    .last_args
                    .as_ref()
                    .unwrap_or(&serde_json::Value::Object(Default::default())),
            ),
            _ => streaming_preview_card(kind, name, preview.last_args.as_ref(), &self.cwd),
        };
        preview.next_parse_length = preview
            .arguments
            .len()
            .saturating_add(kind.preview_parse_stride(preview.arguments.len()));
        if preview.last_card.as_ref() == Some(&card) {
            return None;
        }
        preview.last_card = Some(card.clone());
        // Streaming previews carry no notices or image assets; skip a second
        // argument parse just to assemble ToolPresentation.
        Some(ToolPresentation {
            card,
            image_asset: None,
        })
    }

    pub(crate) fn interrupted(
        &self,
        name: Option<&str>,
        partial_arguments: &str,
    ) -> ToolPresentation {
        let name = name.unwrap_or("tool call");
        let arguments = parse_incomplete_json(partial_arguments)
            .unwrap_or_else(|| serde_json::Value::Object(Default::default()));
        let view = ToolView {
            kind: ToolKind::from_name_and_args(name, Some(&arguments)),
            name: name.into(),
            arguments,
            metadata: ToolMetadata::default(),
        };
        presentation(&view, interrupted_card(&view, partial_arguments, &self.cwd))
    }

    pub(crate) fn historical(
        &self,
        call: &ToolCall,
        ok: bool,
        content: &str,
    ) -> FinishedToolPresentation {
        let view = ToolView {
            kind: ToolKind::from_name_and_args(&call.name, Some(&call.arguments)),
            name: call.name.clone(),
            arguments: call.arguments.clone(),
            metadata: ToolMetadata::default(),
        };
        self.finished_presentation(&view, content, ok)
    }

    pub(crate) fn proposed(&mut self, call: ToolCall) -> ToolPresentation {
        let id = call.id.clone();
        let view = ToolView {
            kind: ToolKind::from_name_and_args(&call.name, Some(&call.arguments)),
            name: call.name,
            arguments: call.arguments,
            metadata: ToolMetadata::default(),
        };
        let presented = presentation(&view, start_card(&view, &self.cwd));
        self.calls.insert(id, view);
        presented
    }

    pub(crate) fn started(
        &mut self,
        call_id: ToolCallId,
        name: String,
        metadata: ToolMetadata,
    ) -> ToolPresentation {
        let id = call_id.to_string();
        let view = self.calls.entry(id).or_insert_with(|| ToolView {
            kind: ToolKind::from_name(&name),
            name: name.clone(),
            arguments: serde_json::Value::Object(Default::default()),
            metadata: metadata.clone(),
        });
        // Keep any format already classified from proposed args; recompute from
        // name + stored args so a late start does not clobber str_replace etc.
        view.kind = ToolKind::from_name_and_args(&name, Some(&view.arguments));
        view.name = name;
        view.metadata = metadata;
        presentation(view, start_card(view, &self.cwd))
    }

    pub(crate) fn updated(
        &mut self,
        call_id: &ToolCallId,
        progress: &ToolProgress,
    ) -> ToolPresentation {
        if let Some(view) = self.calls.get_mut(&call_id.to_string()) {
            if progress.presentation() != &ToolMetadata::default() {
                view.metadata = progress.presentation().clone();
            }
            let card = progress_card(Some((view, &self.cwd)), progress);
            return presentation(view, card);
        }
        let card = progress_card(None, progress);
        let view = ToolView {
            kind: ToolKind::Other,
            name: "tool".into(),
            arguments: serde_json::Value::Object(Default::default()),
            metadata: ToolMetadata::default(),
        };
        presentation(&view, card)
    }

    pub(crate) fn finished(
        &mut self,
        call_id: &ToolCallId,
        result: ToolCompletion,
    ) -> (bool, FinishedToolPresentation) {
        let mut view = self
            .calls
            .remove(&call_id.to_string())
            .unwrap_or_else(|| ToolView {
                kind: ToolKind::Other,
                name: "tool".into(),
                arguments: serde_json::Value::Object(Default::default()),
                metadata: ToolMetadata::default(),
            });
        let (ok, content) = match result {
            ToolCompletion::Success(output) => {
                if output.presentation() != &ToolMetadata::default() {
                    view.metadata = output.presentation().clone();
                }
                (true, output.content().to_string())
            }
            ToolCompletion::Failure(error) => (false, error.message().to_string()),
            ToolCompletion::Unavailable => (false, "tool is unavailable".into()),
            _ => (false, "unknown tool result".into()),
        };
        (ok, self.finished_presentation(&view, &content, ok))
    }

    fn finished_presentation(
        &self,
        view: &ToolView,
        content: &str,
        ok: bool,
    ) -> FinishedToolPresentation {
        if let Some(message) = message_format::finished_message(view, content, ok) {
            return FinishedToolPresentation {
                presentation: crate::presentation::Presentation::Message(message),
                image_asset: None,
            };
        }
        if view.kind == ToolKind::Sessions {
            if let Some(mut card) = sessions_format::finished_card(&view.arguments, content, ok) {
                card.push_notice_facts(view.metadata.presentation_notices());
                return FinishedToolPresentation {
                    presentation: crate::presentation::Presentation::SummaryCard(card),
                    image_asset: None,
                };
            }
        }
        let presented = presentation(view, finished_card(view, content, ok, &self.cwd));
        FinishedToolPresentation {
            presentation: presented.card.into(),
            image_asset: presented.image_asset,
        }
    }
}

#[cfg(test)]
#[path = "interactive_presenter_tests.rs"]
mod tests;