manager: same agent loop, ManagerServer MCP surface
This commit is contained in:
müde
parent
accb1445e3
commit
09787659ab
6 changed files with 422 additions and 142 deletions
|
|
@ -16,6 +16,7 @@
|
|||
//! Both go through the same `run_tool_envelope` helper so logging + status
|
||||
//! line stay uniform.
|
||||
|
||||
use std::future::Future;
|
||||
use std::path::PathBuf;
|
||||
|
||||
use anyhow::Result;
|
||||
|
|
@ -28,6 +29,32 @@ use rmcp::{
|
|||
|
||||
use crate::client;
|
||||
|
||||
/// Common envelope around every MCP tool handler: pre-log → run → append
|
||||
/// a status line → post-log. Free function so both `AgentServer` and
|
||||
/// `ManagerServer` use the same shape; the per-server `status_line`
|
||||
/// closure is what differs (different `Status` wire types).
|
||||
pub async fn run_tool_envelope<F, S>(
|
||||
tool: &'static str,
|
||||
args: String,
|
||||
status: S,
|
||||
body: F,
|
||||
) -> String
|
||||
where
|
||||
F: Future<Output = String>,
|
||||
S: Future<Output = String>,
|
||||
{
|
||||
tracing::info!(tool, %args, "tool: request");
|
||||
let result = body.await;
|
||||
let status_text = status.await;
|
||||
let full = if status_text.is_empty() {
|
||||
result
|
||||
} else {
|
||||
format!("{result}\n\n[status] {status_text}")
|
||||
};
|
||||
tracing::info!(tool, result = %full, "tool: result");
|
||||
full
|
||||
}
|
||||
|
||||
#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
|
||||
pub struct SendArgs {
|
||||
/// Logical agent name to deliver the message to (e.g. `"manager"`,
|
||||
|
|
@ -53,32 +80,6 @@ impl AgentServer {
|
|||
Self { socket }
|
||||
}
|
||||
|
||||
/// Wrap every tool handler in the same envelope:
|
||||
/// 1. Log the request (tool name + args via `Debug`).
|
||||
/// 2. Run the tool's actual logic.
|
||||
/// 3. Append a status line (inbox state) to the result so claude always
|
||||
/// has a current "how many unread messages" hint without an extra
|
||||
/// tool call.
|
||||
/// 4. Log the result body.
|
||||
///
|
||||
/// New tools just call `self.run_tool("name", &args, async { ... })`
|
||||
/// and get the same shape for free.
|
||||
async fn run_tool<F>(&self, tool: &'static str, args: String, body: F) -> String
|
||||
where
|
||||
F: std::future::Future<Output = String>,
|
||||
{
|
||||
tracing::info!(tool, %args, "tool: request");
|
||||
let result = body.await;
|
||||
let status = self.status_line().await;
|
||||
let full = if status.is_empty() {
|
||||
result
|
||||
} else {
|
||||
format!("{result}\n\n[status] {status}")
|
||||
};
|
||||
tracing::info!(tool, result = %full, "tool: result");
|
||||
full
|
||||
}
|
||||
|
||||
/// Non-mutating peek used in the status line. Falls back to a vague
|
||||
/// note rather than failing the whole tool call when the socket
|
||||
/// hiccups.
|
||||
|
|
@ -107,7 +108,7 @@ impl AgentServer {
|
|||
async fn send(&self, Parameters(args): Parameters<SendArgs>) -> String {
|
||||
let log = format!("{args:?}");
|
||||
let to = args.to.clone();
|
||||
self.run_tool("send", log, async move {
|
||||
run_tool_envelope("send", log, self.status_line(), async move {
|
||||
let req = hive_sh4re::AgentRequest::Send {
|
||||
to: args.to,
|
||||
body: args.body,
|
||||
|
|
@ -128,7 +129,7 @@ impl AgentServer {
|
|||
)]
|
||||
async fn recv(&self, Parameters(args): Parameters<RecvArgs>) -> String {
|
||||
let log = format!("{args:?}");
|
||||
self.run_tool("recv", log, async move {
|
||||
run_tool_envelope("recv", log, self.status_line(), async move {
|
||||
let req = hive_sh4re::AgentRequest::Recv;
|
||||
match client::request::<_, hive_sh4re::AgentResponse>(&self.socket, &req).await {
|
||||
Ok(hive_sh4re::AgentResponse::Message { from, body }) => {
|
||||
|
|
@ -151,14 +152,194 @@ impl AgentServer {
|
|||
)]
|
||||
impl ServerHandler for AgentServer {}
|
||||
|
||||
/// Run the MCP server over stdio. Returns when the client disconnects.
|
||||
pub async fn serve_stdio(socket: PathBuf) -> Result<()> {
|
||||
/// Run the agent MCP server over stdio. Returns when the client disconnects.
|
||||
pub async fn serve_agent_stdio(socket: PathBuf) -> Result<()> {
|
||||
let server = AgentServer::new(socket);
|
||||
let service = server.serve(stdio()).await?;
|
||||
service.waiting().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Run the manager MCP server over stdio. Same idea, different tool surface.
|
||||
pub async fn serve_manager_stdio(socket: PathBuf) -> Result<()> {
|
||||
let server = ManagerServer::new(socket);
|
||||
let service = server.serve(stdio()).await?;
|
||||
service.waiting().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Manager tool surface
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
|
||||
pub struct RequestSpawnArgs {
|
||||
/// New sub-agent name (≤9 chars). Queues a Spawn approval; the
|
||||
/// operator approves on the dashboard before the container is created.
|
||||
pub name: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
|
||||
pub struct KillArgs {
|
||||
/// Sub-agent name (without the `h-` container prefix).
|
||||
pub name: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
|
||||
pub struct RequestApplyCommitArgs {
|
||||
/// Agent whose config repo the commit lives in (use `"hm1nd"` for the
|
||||
/// manager's own config).
|
||||
pub agent: String,
|
||||
/// Git sha (full or short) pointing at the proposed `agent.nix`.
|
||||
pub commit_ref: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ManagerServer {
|
||||
socket: PathBuf,
|
||||
}
|
||||
|
||||
impl ManagerServer {
|
||||
#[must_use]
|
||||
pub fn new(socket: PathBuf) -> Self {
|
||||
Self { socket }
|
||||
}
|
||||
|
||||
async fn status_line(&self) -> String {
|
||||
match client::request::<_, hive_sh4re::ManagerResponse>(
|
||||
&self.socket,
|
||||
&hive_sh4re::ManagerRequest::Status,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(hive_sh4re::ManagerResponse::Status { unread }) => {
|
||||
format!("{unread} unread message(s) in inbox")
|
||||
}
|
||||
Ok(other) => format!("status: unexpected response {other:?}"),
|
||||
Err(e) => format!("status: transport error: {e:#}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tool_router]
|
||||
impl ManagerServer {
|
||||
#[tool(description = "Send a message to a sub-agent (by logical name), to another agent, \
|
||||
or to the operator (recipient `operator`, surfaces in the dashboard).")]
|
||||
async fn send(&self, Parameters(args): Parameters<SendArgs>) -> String {
|
||||
let log = format!("{args:?}");
|
||||
let to = args.to.clone();
|
||||
run_tool_envelope("send", log, self.status_line(), async move {
|
||||
let req = hive_sh4re::ManagerRequest::Send {
|
||||
to: args.to,
|
||||
body: args.body,
|
||||
};
|
||||
match client::request::<_, hive_sh4re::ManagerResponse>(&self.socket, &req).await {
|
||||
Ok(hive_sh4re::ManagerResponse::Ok) => format!("sent to {to}"),
|
||||
Ok(hive_sh4re::ManagerResponse::Err { message }) => {
|
||||
format!("send failed: {message}")
|
||||
}
|
||||
Ok(other) => format!("send unexpected response: {other:?}"),
|
||||
Err(e) => format!("send transport error: {e:#}"),
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[tool(description = "Pop one message from the manager inbox. Returns sender + body, or \
|
||||
empty.")]
|
||||
async fn recv(&self, Parameters(args): Parameters<RecvArgs>) -> String {
|
||||
let log = format!("{args:?}");
|
||||
run_tool_envelope("recv", log, self.status_line(), async move {
|
||||
let req = hive_sh4re::ManagerRequest::Recv;
|
||||
match client::request::<_, hive_sh4re::ManagerResponse>(&self.socket, &req).await {
|
||||
Ok(hive_sh4re::ManagerResponse::Message { from, body }) => {
|
||||
format!("from: {from}\n\n{body}")
|
||||
}
|
||||
Ok(hive_sh4re::ManagerResponse::Empty) => "(empty)".into(),
|
||||
Ok(hive_sh4re::ManagerResponse::Err { message }) => format!("recv failed: {message}"),
|
||||
Ok(other) => format!("recv unexpected response: {other:?}"),
|
||||
Err(e) => format!("recv transport error: {e:#}"),
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[tool(description = "Queue a Spawn approval for a brand-new sub-agent. The operator \
|
||||
approves on the dashboard before the container is actually created.")]
|
||||
async fn request_spawn(&self, Parameters(args): Parameters<RequestSpawnArgs>) -> String {
|
||||
let log = format!("{args:?}");
|
||||
let name = args.name.clone();
|
||||
run_tool_envelope("request_spawn", log, self.status_line(), async move {
|
||||
let req = hive_sh4re::ManagerRequest::RequestSpawn { name: args.name };
|
||||
match client::request::<_, hive_sh4re::ManagerResponse>(&self.socket, &req).await {
|
||||
Ok(hive_sh4re::ManagerResponse::Ok) => format!("spawn approval queued for {name}"),
|
||||
Ok(hive_sh4re::ManagerResponse::Err { message }) => {
|
||||
format!("request_spawn failed: {message}")
|
||||
}
|
||||
Ok(other) => format!("request_spawn unexpected response: {other:?}"),
|
||||
Err(e) => format!("request_spawn transport error: {e:#}"),
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[tool(description = "Stop a sub-agent container (graceful). The state dir is kept; \
|
||||
recreating reuses prior config + Claude credentials.")]
|
||||
async fn kill(&self, Parameters(args): Parameters<KillArgs>) -> String {
|
||||
let log = format!("{args:?}");
|
||||
let name = args.name.clone();
|
||||
run_tool_envelope("kill", log, self.status_line(), async move {
|
||||
let req = hive_sh4re::ManagerRequest::Kill { name: args.name };
|
||||
match client::request::<_, hive_sh4re::ManagerResponse>(&self.socket, &req).await {
|
||||
Ok(hive_sh4re::ManagerResponse::Ok) => format!("killed {name}"),
|
||||
Ok(hive_sh4re::ManagerResponse::Err { message }) => format!("kill failed: {message}"),
|
||||
Ok(other) => format!("kill unexpected response: {other:?}"),
|
||||
Err(e) => format!("kill transport error: {e:#}"),
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[tool(description = "Submit a config change for operator approval. Pass the agent name \
|
||||
(e.g. `alice` or `hm1nd` for the manager's own config) and a commit sha in that \
|
||||
agent's proposed config repo. On approval hive-c0re rebuilds the container.")]
|
||||
async fn request_apply_commit(
|
||||
&self,
|
||||
Parameters(args): Parameters<RequestApplyCommitArgs>,
|
||||
) -> String {
|
||||
let log = format!("{args:?}");
|
||||
let agent = args.agent.clone();
|
||||
let commit_ref = args.commit_ref.clone();
|
||||
run_tool_envelope("request_apply_commit", log, self.status_line(), async move {
|
||||
let req = hive_sh4re::ManagerRequest::RequestApplyCommit {
|
||||
agent: args.agent,
|
||||
commit_ref: args.commit_ref,
|
||||
};
|
||||
match client::request::<_, hive_sh4re::ManagerResponse>(&self.socket, &req).await {
|
||||
Ok(hive_sh4re::ManagerResponse::Ok) => {
|
||||
format!("apply approval queued for {agent} @ {commit_ref}")
|
||||
}
|
||||
Ok(hive_sh4re::ManagerResponse::Err { message }) => {
|
||||
format!("request_apply_commit failed: {message}")
|
||||
}
|
||||
Ok(other) => format!("request_apply_commit unexpected response: {other:?}"),
|
||||
Err(e) => format!("request_apply_commit transport error: {e:#}"),
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
}
|
||||
|
||||
#[tool_handler(
|
||||
instructions = "You are the hyperhive manager (hm1nd). You coordinate sub-agents and \
|
||||
relay between them and the operator. Use `send` to talk to agents/operator, `recv` \
|
||||
to drain your inbox. Privileged: `request_spawn` (new agent, gated on operator \
|
||||
approval), `kill` (graceful stop), `request_apply_commit` (config change for \
|
||||
any agent including yourself). The manager's own config lives at \
|
||||
`/agents/hm1nd/config/agent.nix`."
|
||||
)]
|
||||
impl ServerHandler for ManagerServer {}
|
||||
|
||||
/// Name of the hyperhive MCP server inside claude's view. Claude prefixes
|
||||
/// tools as `mcp__<this>__<tool>` (e.g. `mcp__hyperhive__send`).
|
||||
pub const SERVER_NAME: &str = "hyperhive";
|
||||
|
|
@ -180,12 +361,25 @@ pub const ALLOWED_BUILTIN_TOOLS: &[&str] = &[
|
|||
"Write",
|
||||
];
|
||||
|
||||
/// Which MCP tool surface to advertise via `--allowedTools`. The agent
|
||||
/// list is the strict subset of the manager list, so we just thread the
|
||||
/// flavor through.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum Flavor {
|
||||
Agent,
|
||||
Manager,
|
||||
}
|
||||
|
||||
/// MCP tools claude is allowed to call without prompting. Mirrors the
|
||||
/// hyperhive surface so a new tool added below propagates to claude's
|
||||
/// allow-list automatically.
|
||||
/// hyperhive surface so a new tool added in the corresponding `#[tool_router]`
|
||||
/// impl needs to be listed here too.
|
||||
#[must_use]
|
||||
pub fn allowed_mcp_tools() -> Vec<String> {
|
||||
["send", "recv"]
|
||||
pub fn allowed_mcp_tools(flavor: Flavor) -> Vec<String> {
|
||||
let names: &[&str] = match flavor {
|
||||
Flavor::Agent => &["send", "recv"],
|
||||
Flavor::Manager => &["send", "recv", "request_spawn", "kill", "request_apply_commit"],
|
||||
};
|
||||
names
|
||||
.iter()
|
||||
.map(|t| format!("mcp__{SERVER_NAME}__{t}"))
|
||||
.collect()
|
||||
|
|
@ -194,9 +388,9 @@ pub fn allowed_mcp_tools() -> Vec<String> {
|
|||
/// Combined allow-list passed to `--allowedTools` (auto-approve) — covers
|
||||
/// both the built-ins and the MCP surface.
|
||||
#[must_use]
|
||||
pub fn allowed_tools_arg() -> String {
|
||||
pub fn allowed_tools_arg(flavor: Flavor) -> String {
|
||||
let mut all: Vec<String> = ALLOWED_BUILTIN_TOOLS.iter().map(|s| (*s).to_owned()).collect();
|
||||
all.extend(allowed_mcp_tools());
|
||||
all.extend(allowed_mcp_tools(flavor));
|
||||
all.join(",")
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue