rho-coding-agent 2.10.0

A fast Rust agent harness with a small footprint and opinionated defaults
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Deferred MCP connect and pre-request system prompt refresh.

use futures_util::FutureExt;
use rho_sdk::SystemPrompt;

use super::InteractiveRuntime;
use crate::{model_identity::PromptModel, prompt, tools::mcp::McpConnectOutcome};

impl InteractiveRuntime {
    pub(crate) fn mcp_connect_pending(&self) -> bool {
        self.pending_mcp.is_some()
    }

    pub(crate) fn startup_hydrate_pending(&self) -> bool {
        self.pending_mcp.is_some() || self.pending_catalog_names.is_some()
    }

    pub(crate) fn cancel_startup_hydrates(&mut self) {
        if let Some(handle) = self.pending_mcp.take() {
            handle.abort();
        }
        if let Some(handle) = self.pending_catalog_names.take() {
            handle.abort();
        }
    }

    /// Apply finished MCP connect and catalog-name hydrates. Returns whether
    /// `/mcp` inventory or the startup prompt changed.
    pub(crate) async fn poll_startup_hydrates(&mut self) -> anyhow::Result<bool> {
        let mut changed = false;
        if let Some(handle) = self.pending_mcp.as_mut() {
            if handle.is_finished() {
                if let Some(handle) = self.pending_mcp.take() {
                    match handle.now_or_never() {
                        Some(Ok(outcome)) => {
                            self.apply_mcp_connect(outcome).await?;
                            changed = true;
                        }
                        // The connect task died without reporting. Say so, or
                        // `/mcp` sits on `connecting` until the session ends.
                        Some(Err(error)) => {
                            self.mcp_report
                                .fail_connecting(&format!("MCP connect did not finish: {error}"));
                            changed = true;
                        }
                        None => {}
                    }
                }
            }
        }
        if let Some(handle) = self.pending_catalog_names.as_mut() {
            if handle.is_finished() {
                if let Some(handle) = self.pending_catalog_names.take() {
                    let _ = handle.now_or_never();
                    if self.pending_mcp.is_none() {
                        let prompt_changed = self.refresh_startup_system_prompt()?;
                        if prompt_changed {
                            self.replace_history_system_prompt()?;
                        }
                        changed |= prompt_changed;
                    }
                }
            }
        }
        Ok(changed)
    }

    async fn apply_mcp_connect(&mut self, outcome: McpConnectOutcome) -> anyhow::Result<()> {
        let instructions = outcome
            .report
            .servers
            .iter()
            .filter_map(|server| Some((server.identity.as_str(), server.instructions()?)))
            .map(|(identity, text)| (identity.to_string(), text.to_string()))
            .collect::<Vec<_>>();
        self.tools.attach_mcp(outcome);
        self.mcp_report = self.tools.mcp_report().clone();
        if let Some(template) = self.prompt_template.as_mut() {
            let mut retained = String::new();
            prompt::append_mcp_instructions(
                &mut retained,
                instructions
                    .iter()
                    .map(|(identity, text)| (identity.as_str(), text.as_str())),
            );
            template.append_retained(&retained);
        }
        let prompt_changed = self.refresh_startup_system_prompt()?;
        self.rebind_current_session().await?;
        self.remember_tool_list();
        if prompt_changed {
            self.replace_history_system_prompt()?;
        } else if !instructions.is_empty() && !self.may_rewrite_startup_prompt {
            let mut notice = String::new();
            prompt::append_mcp_instructions(
                &mut notice,
                instructions
                    .iter()
                    .map(|(identity, text)| (identity.as_str(), text.as_str())),
            );
            if !notice.is_empty() {
                let _ = self.append_user_context_with_display(notice.clone(), notice);
            }
        }
        Ok(())
    }

    fn refresh_startup_system_prompt(&mut self) -> anyhow::Result<bool> {
        if !self.may_rewrite_startup_prompt || self.live_context_warm {
            return Ok(false);
        }
        let Some(template) = self.prompt_template.as_ref() else {
            return Ok(false);
        };
        // Catalog hydration changes display names, not the selected file. Keep
        // startup AGENTS/skills and the loaded model prompt without filesystem IO.
        let running = PromptModel::from_sdk_identity(&self.provider.provider().identity());
        let built = template.render(&running, self.sessions.prompt.loaded.as_ref());
        if self.sessions.prompt.system == SystemPrompt::Custom(built.text.clone()) {
            return Ok(false);
        }
        // Hydration retains its startup lifetime until an explicit transition.
        self.sessions.prompt.adopt(
            crate::app::active_prompt::ActivePrompt::from_prepared(built),
            &self.diagnostics,
            self.tools.advisor(),
        );
        Ok(true)
    }

    fn replace_history_system_prompt(&mut self) -> anyhow::Result<()> {
        let SystemPrompt::Custom(prompt) = &self.sessions.prompt.system else {
            return Ok(());
        };
        crate::app::conversation_switch::replace_system_prompt(self.sessions.session(), prompt)?;
        Ok(())
    }
}