rho-coding-agent 2.23.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

use std::{path::Path, sync::Arc};

use agent_client_protocol::schema::v1::SessionModeState;
use rho_sdk::{provider::ModelProvider, ApprovalSession, SessionOptions};

use super::super::{permission, AcpHost, AcpStartup};
use crate::{
    added_dirs::AddedDirs,
    app::{
        agent_binding::BoundAgent,
        automation::ensure_headless_auto_classifier_model,
        interactive_runtime::startup::{
            approval_channel_for, ApprovalChannel, ApprovalChannelOptions,
        },
        session_assembly::{
            assemble_session, ApprovalInputs, SessionApproval, SessionAssembly,
            SessionAssemblyOptions,
        },
        tools_prompt::McpSamplingSupport,
    },
    config::Config,
    permission::PermissionMode,
};

/// `config` is the session's config: the process config plus host-supplied
/// MCP servers. `added_dirs` is the session's set: launch `--add-dir` values,
/// plus any a loaded session saved.
pub(super) async fn build_session(
    startup: &AcpStartup,
    agent: &BoundAgent,
    config: &Config,
    workspace: &Path,
    added_dirs: &AddedDirs,
    session_options: impl FnOnce(Arc<dyn ModelProvider>) -> anyhow::Result<SessionOptions>,
) -> anyhow::Result<SessionAssembly> {
    ensure_headless_auto_classifier_model(config)?;
    let mut host_tools: anyhow::Result<()> = Ok(());
    let assembly = assemble_session(SessionAssemblyOptions {
        config,
        config_path: startup.config_path.clone(),
        cwd: workspace,
        no_system_prompt: startup.no_system_prompt,
        no_tools: startup.no_tools,
        no_subagents: startup.no_subagents,
        questionnaire_enabled: false,
        mcp_elicitation: crate::tools::mcp::McpElicitationSupport::Unavailable,
        mcp_sampling: McpSamplingSupport::Unavailable,
        mcp_attach: crate::app::tools_prompt::McpAttach::Connect,
        diagnostics: &startup.diagnostics,
        agent,
        max_steps: None,
        usage_purpose: "agent",
        usage_parent_session_id: None,
        hook_host_labels: rho_sdk::hooks::HookHostLabels::new(),
        added_dirs,
        // `--t3code`: the `agent` tool delegates to T3 so its UI owns children.
        extend_tools: |mut tools| {
            match startup.host {
                AcpHost::Generic => {}
                AcpHost::T3Code => {
                    host_tools = crate::tools::agent::install_host_delegation(
                        &mut tools,
                        workspace,
                        config.max_output_bytes,
                    );
                }
            }
            tools
        },
        system_prompt_suffix: None,
        approval: |inputs: ApprovalInputs| {
            let ApprovalChannel {
                handler, receiver, ..
            } = approval_channel_for(
                inputs.config.permission_mode,
                ApprovalChannelOptions {
                    config: inputs.config,
                    workspace_path: inputs.workspace_root,
                    usage_recording: inputs.usage_recording,
                    session_writes: inputs.session_writes,
                },
            );
            Ok(SessionApproval {
                session: handler.map(ApprovalSession::from_shared),
                receiver,
            })
        },
        session_options,
    })
    .await?;
    if let Err(error) = host_tools {
        assembly.built.teardown().await;
        return Err(error);
    }
    Ok(assembly)
}

pub(super) fn mode_state(mode: PermissionMode) -> SessionModeState {
    SessionModeState::new(permission::mode_id(mode), permission::mode_list())
}

/// The process config with the host's `mcpServers` merged in. A host entry
/// replaces a config server of the same name for this session only, and an
/// invalid host entry suppresses it.
pub(super) fn session_config(
    process: &Config,
    host_servers: &[agent_client_protocol::schema::v1::McpServer],
) -> Config {
    let mut config = process.clone();
    super::super::host_mcp::overlay_host_mcp(&mut config.mcp, host_servers);
    config
}