3408 lines
119 KiB
Rust
3408 lines
119 KiB
Rust
use crate::app::AppState;
|
||
use crate::context::RequestContext;
|
||
use crate::error::WebError;
|
||
use crate::transport::convex::execute_convex_query_by_name;
|
||
use axum::body::Body;
|
||
use axum::extract::{Extension, Path, Query, State};
|
||
use axum::http::{header, HeaderMap, HeaderName, HeaderValue, StatusCode};
|
||
use axum::response::Response;
|
||
use axum::Json;
|
||
use futures_util::TryStreamExt;
|
||
use serde::Deserialize;
|
||
use serde_json::{json, Value};
|
||
use std::collections::{HashMap, HashSet, VecDeque};
|
||
use std::fs;
|
||
use std::path::{Path as FsPath, PathBuf};
|
||
use std::process::Command;
|
||
use std::sync::{LazyLock, Mutex};
|
||
use std::time::Duration;
|
||
use std::time::{SystemTime, UNIX_EPOCH};
|
||
use tracing::warn;
|
||
|
||
const HEADER_MNOTE_WEB_OWNER: &str = "x-mnote-web-owner";
|
||
const HEADER_HERMES_CLIENT_OWNER: &str = "x-mnote-hermes-client-owner";
|
||
|
||
static HERMES_RUNTIME_REGISTRY: LazyLock<Mutex<HashMap<String, HermesRuntimeState>>> =
|
||
LazyLock::new(|| Mutex::new(HashMap::new()));
|
||
static HERMES_RUN_QUEUE: LazyLock<Mutex<HashMap<String, VecDeque<HermesQueuedRun>>>> =
|
||
LazyLock::new(|| Mutex::new(HashMap::new()));
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct HermesRuntimeState {
|
||
session_id: String,
|
||
run_id: String,
|
||
profile: String,
|
||
document_id: String,
|
||
trace_id: String,
|
||
status: String,
|
||
started_at: u128,
|
||
last_event_at: u128,
|
||
last_event: Option<String>,
|
||
last_tool_name: Option<String>,
|
||
last_tool_call_id: Option<String>,
|
||
last_audit_id: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct HermesRunRegistration {
|
||
session_id: String,
|
||
profile: String,
|
||
document_id: String,
|
||
trace_id: String,
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct HermesQueuedRun {
|
||
queue_id: String,
|
||
session_id: String,
|
||
profile: String,
|
||
document_id: String,
|
||
trace_id: String,
|
||
actor_id: String,
|
||
actor_type: String,
|
||
input: String,
|
||
context_summary: Value,
|
||
queued_at: u128,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct CreateSessionRequest {
|
||
workspace_id: Option<String>,
|
||
document_id: Option<String>,
|
||
trace_id: Option<String>,
|
||
title: Option<String>,
|
||
profile: Option<String>,
|
||
}
|
||
|
||
pub async fn list_sessions(
|
||
Extension(context): Extension<RequestContext>,
|
||
Query(query): Query<HashMap<String, String>>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let Some(upstream) = configured_upstream() else {
|
||
return hermes_unconfigured(&context);
|
||
};
|
||
let mut path = "/api/hermes/sessions".to_string();
|
||
if !query.is_empty() {
|
||
let params = query
|
||
.iter()
|
||
.map(|(key, value)| format!("{}={}", url_escape(key), url_escape(value)))
|
||
.collect::<Vec<_>>()
|
||
.join("&");
|
||
path.push('?');
|
||
path.push_str(¶ms);
|
||
}
|
||
proxy_json(&context, reqwest::Method::GET, &upstream, &path, None).await
|
||
}
|
||
|
||
pub async fn create_session(
|
||
Extension(context): Extension<RequestContext>,
|
||
Json(payload): Json<CreateSessionRequest>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let trace_id = payload
|
||
.trace_id
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or_else(|| context.trace.trace_id.clone());
|
||
let document_id = payload
|
||
.document_id
|
||
.as_deref()
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or("current");
|
||
let session_id = stable_session_id(document_id, &trace_id);
|
||
let profile = payload
|
||
.profile
|
||
.as_deref()
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.unwrap_or("default");
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({
|
||
"ok": true,
|
||
"sessionId": session_id,
|
||
"workspaceId": payload.workspace_id,
|
||
"documentId": payload.document_id,
|
||
"profile": profile,
|
||
"title": payload.title.unwrap_or_else(|| "当前页问答".into()),
|
||
"traceId": trace_id,
|
||
"persistence": "hermes_on_first_run"
|
||
})),
|
||
))
|
||
}
|
||
|
||
pub async fn list_profiles(
|
||
Extension(context): Extension<RequestContext>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(list_profiles_payload()),
|
||
))
|
||
}
|
||
|
||
pub async fn gateway_health(
|
||
Extension(context): Extension<RequestContext>,
|
||
Query(query): Query<HashMap<String, String>>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let profile = query
|
||
.get("profile")
|
||
.map(String::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.map(ToOwned::to_owned)
|
||
.or_else(active_profile_name)
|
||
.unwrap_or_else(|| "default".into());
|
||
let upstream = configured_upstream();
|
||
let profile_status = profile_gateway_status(&profile);
|
||
let mut suggestions = profile_status
|
||
.get("suggestions")
|
||
.and_then(Value::as_array)
|
||
.cloned()
|
||
.unwrap_or_default();
|
||
if upstream.is_none() {
|
||
suggestions.push(Value::String(
|
||
"未配置 MNOTE_WEB_HERMES_UPSTREAM_URL；请先启动 Hermes gateway，并让 mnote-web 指向该 gateway。"
|
||
.into(),
|
||
));
|
||
}
|
||
|
||
let mut gateway = json!({
|
||
"configured": upstream.is_some(),
|
||
"upstream": upstream,
|
||
"ok": false,
|
||
"status": if upstream.is_some() { "checking" } else { "unconfigured" }
|
||
});
|
||
if let Some(upstream_url) = gateway["upstream"].as_str().map(ToOwned::to_owned) {
|
||
let probe = probe_gateway_health(&upstream_url).await;
|
||
gateway["ok"] = Value::Bool(probe.ok);
|
||
gateway["status"] = Value::String(probe.status);
|
||
gateway["httpStatus"] = probe.http_status.map(Value::from).unwrap_or(Value::Null);
|
||
gateway["path"] = probe.path.map(Value::from).unwrap_or(Value::Null);
|
||
gateway["message"] = probe.message.map(Value::from).unwrap_or(Value::Null);
|
||
if !probe.ok {
|
||
suggestions.extend(
|
||
hermes_settings_suggestions(
|
||
gateway["httpStatus"].as_u64(),
|
||
gateway["message"].as_str(),
|
||
)
|
||
.into_iter()
|
||
.map(Value::String),
|
||
);
|
||
}
|
||
}
|
||
let ok = gateway["ok"].as_bool().unwrap_or(false)
|
||
&& profile_status["modelConfigured"].as_bool().unwrap_or(false)
|
||
&& profile_status["apiKeyConfigured"]
|
||
.as_bool()
|
||
.unwrap_or(false);
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({
|
||
"ok": ok,
|
||
"traceId": context.trace.trace_id,
|
||
"profile": profile_status,
|
||
"gateway": gateway,
|
||
"suggestions": unique_string_values(suggestions)
|
||
})),
|
||
))
|
||
}
|
||
|
||
pub async fn get_profile(
|
||
Extension(context): Extension<RequestContext>,
|
||
Path(profile_name): Path<String>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({
|
||
"ok": true,
|
||
"profile": profile_detail_payload(&profile_name)
|
||
})),
|
||
))
|
||
}
|
||
|
||
pub async fn switch_active_profile(
|
||
Extension(context): Extension<RequestContext>,
|
||
Json(payload): Json<Value>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let name = payload
|
||
.get("name")
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.ok_or_else(|| {
|
||
WebError::bad_request_code("hermes_client_bad_request", "缺少 profile name")
|
||
.with_context(&context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
switch_active_profile_local(name).map_err(|error| {
|
||
WebError::bad_gateway_code(
|
||
"hermes_client_profile_switch_failed",
|
||
format!("切换 Hermes profile 失败: {error}"),
|
||
)
|
||
.with_context(&context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({
|
||
"ok": true,
|
||
"profile": profile_detail_payload(name)
|
||
})),
|
||
))
|
||
}
|
||
|
||
pub async fn get_profile_memory(
|
||
Extension(context): Extension<RequestContext>,
|
||
Query(query): Query<HashMap<String, String>>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let fallback_profile = active_profile_name().unwrap_or_else(|| "default".into());
|
||
let profile = query
|
||
.get("profile")
|
||
.map(String::as_str)
|
||
.unwrap_or(fallback_profile.as_str());
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(profile_memory_payload(profile)),
|
||
))
|
||
}
|
||
|
||
pub async fn save_profile_memory(
|
||
Extension(context): Extension<RequestContext>,
|
||
Json(payload): Json<Value>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let fallback_profile = active_profile_name().unwrap_or_else(|| "default".into());
|
||
let profile = payload
|
||
.get("profile")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or(fallback_profile.as_str());
|
||
let section = payload
|
||
.get("section")
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| matches!(*value, "memory" | "user" | "soul"))
|
||
.ok_or_else(|| {
|
||
WebError::bad_request_code(
|
||
"hermes_client_bad_request",
|
||
"section 必须是 memory、user 或 soul",
|
||
)
|
||
.with_context(&context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
let content = payload
|
||
.get("content")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or_default();
|
||
save_profile_memory_local(profile, section, content).map_err(|error| {
|
||
WebError::bad_gateway_code(
|
||
"hermes_client_memory_save_failed",
|
||
format!("保存 Hermes profile memory 失败: {error}"),
|
||
)
|
||
.with_context(&context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({"ok": true})),
|
||
))
|
||
}
|
||
|
||
pub async fn list_skills(
|
||
Extension(context): Extension<RequestContext>,
|
||
Query(query): Query<HashMap<String, String>>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let fallback_profile = active_profile_name().unwrap_or_else(|| "default".into());
|
||
let profile = query
|
||
.get("profile")
|
||
.map(String::as_str)
|
||
.unwrap_or(fallback_profile.as_str());
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(skills_payload(profile)),
|
||
))
|
||
}
|
||
|
||
pub async fn toggle_skill(
|
||
Extension(context): Extension<RequestContext>,
|
||
Json(payload): Json<Value>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let name = payload
|
||
.get("name")
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.ok_or_else(|| {
|
||
WebError::bad_request_code("hermes_client_bad_request", "缺少 skill name")
|
||
.with_context(&context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
let enabled = payload
|
||
.get("enabled")
|
||
.and_then(Value::as_bool)
|
||
.ok_or_else(|| {
|
||
WebError::bad_request_code("hermes_client_bad_request", "缺少 enabled")
|
||
.with_context(&context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
let fallback_profile = active_profile_name().unwrap_or_else(|| "default".into());
|
||
let profile = payload
|
||
.get("profile")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or(fallback_profile.as_str());
|
||
set_skill_enabled(profile, name, enabled).map_err(|error| {
|
||
WebError::bad_gateway_code(
|
||
"hermes_client_skill_toggle_failed",
|
||
format!("更新 Hermes skill 设置失败: {error}"),
|
||
)
|
||
.with_context(&context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({"ok": true})),
|
||
))
|
||
}
|
||
|
||
pub async fn get_session(
|
||
Extension(context): Extension<RequestContext>,
|
||
Path(session_id): Path<String>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let runtime = runtime_state_for_session(&session_id);
|
||
if let Some(session) = load_session_from_hermes_cli(&session_id).await {
|
||
return Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({
|
||
"ok": true,
|
||
"traceId": context.trace.trace_id,
|
||
"sessionId": session_id,
|
||
"session": session,
|
||
"runtime": runtime
|
||
})),
|
||
));
|
||
}
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({
|
||
"ok": true,
|
||
"traceId": context.trace.trace_id,
|
||
"sessionId": session_id,
|
||
"session": {
|
||
"sessionId": session_id,
|
||
"messages": []
|
||
},
|
||
"runtime": runtime
|
||
})),
|
||
))
|
||
}
|
||
|
||
pub async fn resume_session(
|
||
Extension(context): Extension<RequestContext>,
|
||
Path(session_id): Path<String>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
get_session(Extension(context), Path(session_id)).await
|
||
}
|
||
|
||
async fn load_session_from_hermes_cli(session_id: &str) -> Option<Value> {
|
||
let session_id = session_id.to_string();
|
||
tokio::task::spawn_blocking(move || {
|
||
let hermes_bin = std::env::var("MNOTE_WEB_HERMES_BIN")
|
||
.ok()
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or_else(|| "hermes".into());
|
||
let output = Command::new(hermes_bin)
|
||
.args(["sessions", "export", "--session-id", &session_id, "-"])
|
||
.output()
|
||
.ok()?;
|
||
if !output.status.success() {
|
||
return None;
|
||
}
|
||
let stdout = String::from_utf8(output.stdout).ok()?;
|
||
stdout
|
||
.lines()
|
||
.find_map(|line| serde_json::from_str::<Value>(line).ok())
|
||
})
|
||
.await
|
||
.ok()
|
||
.flatten()
|
||
}
|
||
|
||
pub async fn create_run(
|
||
State(state): State<AppState>,
|
||
Extension(context): Extension<RequestContext>,
|
||
Json(mut payload): Json<Value>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let (actor_id, actor_type) = resolve_run_actor(&state, &context).await;
|
||
stamp_run_actor(&mut payload, &actor_id, &actor_type);
|
||
let registration = run_registration_from_payload(&context, &payload);
|
||
if session_has_active_run(®istration.session_id) {
|
||
let queued = enqueue_run(&context, ®istration, &payload)?;
|
||
return Ok((StatusCode::ACCEPTED, stamp_client_headers(), Json(queued)));
|
||
}
|
||
let Some(upstream) = configured_upstream() else {
|
||
return hermes_unconfigured(&context);
|
||
};
|
||
let upstream_body = build_run_upstream_body(&context, payload)?;
|
||
let result = proxy_json(
|
||
&context,
|
||
reqwest::Method::POST,
|
||
&upstream,
|
||
"/v1/runs",
|
||
Some(upstream_body),
|
||
)
|
||
.await?;
|
||
if let Some(runtime) = register_runtime_from_create_run_response(®istration, &result.2 .0) {
|
||
let mut payload = result.2 .0;
|
||
payload["runtime"] = runtime;
|
||
Ok((result.0, result.1, Json(payload)))
|
||
} else {
|
||
Ok(result)
|
||
}
|
||
}
|
||
|
||
pub async fn cancel_queued_run(
|
||
Extension(context): Extension<RequestContext>,
|
||
Path((session_id, queue_id)): Path<(String, String)>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let cancelled = remove_queued_run(&session_id, &queue_id);
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({
|
||
"ok": true,
|
||
"sessionId": session_id,
|
||
"queueId": queue_id,
|
||
"cancelled": cancelled,
|
||
"queueLength": queue_len_for_session(&session_id)
|
||
})),
|
||
))
|
||
}
|
||
|
||
pub async fn stream_events(
|
||
Extension(context): Extension<RequestContext>,
|
||
Path(run_id): Path<String>,
|
||
) -> Result<Response, WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let Some(upstream) = configured_upstream() else {
|
||
return Err(hermes_unconfigured_error(&context));
|
||
};
|
||
let url = upstream_url(
|
||
&upstream,
|
||
&format!("/v1/runs/{}/events", url_escape(&run_id)),
|
||
)?;
|
||
let mut request = reqwest::Client::builder()
|
||
.timeout(Duration::from_secs(1800))
|
||
.build()
|
||
.map_err(|error| {
|
||
WebError::internal(format!("Hermes client 构造失败: {error}")).with_context(&context)
|
||
})?
|
||
.get(url);
|
||
if let Some(api_key) = configured_api_key() {
|
||
request = request.bearer_auth(api_key);
|
||
}
|
||
let upstream_response = request.send().await.map_err(|error| {
|
||
WebError::bad_gateway_code(
|
||
"hermes_client_upstream_unavailable",
|
||
format!("Hermes events upstream 连接失败: {error}"),
|
||
)
|
||
.with_context(&context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
if !upstream_response.status().is_success() {
|
||
let status = upstream_response.status();
|
||
let text = upstream_response.text().await.unwrap_or_default();
|
||
return Err(upstream_error(&context, status, text));
|
||
}
|
||
|
||
let run_id_for_stream = run_id.clone();
|
||
let context_for_queue = context.clone();
|
||
update_runtime_by_run_id(&run_id, "running", Some("events.connected"), None);
|
||
let stream = upstream_response
|
||
.bytes_stream()
|
||
.map_ok(move |chunk| {
|
||
let text = String::from_utf8_lossy(&chunk);
|
||
let (normalized, terminal_sessions) =
|
||
normalize_sse_chunk(&run_id_for_stream, text.as_ref());
|
||
for session_id in terminal_sessions {
|
||
let context = context_for_queue.clone();
|
||
tokio::spawn(async move {
|
||
start_next_queued_run(context, session_id).await;
|
||
});
|
||
}
|
||
axum::body::Bytes::from(normalized)
|
||
})
|
||
.map_err(|error| {
|
||
std::io::Error::new(
|
||
std::io::ErrorKind::Other,
|
||
format!("Hermes events stream 读取失败: {error}"),
|
||
)
|
||
});
|
||
let mut response = Response::builder()
|
||
.status(StatusCode::OK)
|
||
.header(header::CONTENT_TYPE, "text/event-stream; charset=utf-8")
|
||
.header(header::CACHE_CONTROL, "no-cache, no-transform")
|
||
.header("x-accel-buffering", "no")
|
||
.body(Body::from_stream(stream))
|
||
.map_err(|error| WebError::internal(format!("Hermes events 响应构造失败: {error}")))?;
|
||
stamp_client_headers_into(response.headers_mut());
|
||
Ok(response)
|
||
}
|
||
|
||
pub async fn abort_run(
|
||
Extension(context): Extension<RequestContext>,
|
||
Path(run_id): Path<String>,
|
||
Json(payload): Json<Value>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let Some(upstream) = configured_upstream() else {
|
||
return hermes_unconfigured(&context);
|
||
};
|
||
let queued_session_id = session_id_for_run(&run_id);
|
||
update_runtime_by_run_id(&run_id, "aborting", Some("abort.started"), None);
|
||
let result = proxy_json(
|
||
&context,
|
||
reqwest::Method::POST,
|
||
&upstream,
|
||
&format!("/v1/runs/{}/stop", url_escape(&run_id)),
|
||
Some(payload),
|
||
)
|
||
.await;
|
||
match result {
|
||
Ok((status, headers, Json(mut payload))) => {
|
||
update_runtime_by_run_id(&run_id, "aborted", Some("abort.completed"), None);
|
||
payload["runtime"] = runtime_state_for_run(&run_id).unwrap_or(Value::Null);
|
||
payload["events"] = json!([
|
||
{"event": "abort.started", "runId": run_id},
|
||
{"event": "abort.completed", "runId": run_id}
|
||
]);
|
||
if let Some(session_id) = queued_session_id {
|
||
start_next_queued_run(context.clone(), session_id).await;
|
||
}
|
||
Ok((status, headers, Json(payload)))
|
||
}
|
||
Err(error) => {
|
||
update_runtime_by_run_id(&run_id, "failed", Some("abort.failed"), None);
|
||
Err(error)
|
||
}
|
||
}
|
||
}
|
||
|
||
pub async fn list_models(
|
||
Extension(context): Extension<RequestContext>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
let Some(upstream) = configured_upstream() else {
|
||
return hermes_unconfigured(&context);
|
||
};
|
||
proxy_json(
|
||
&context,
|
||
reqwest::Method::GET,
|
||
&upstream,
|
||
"/v1/models",
|
||
None,
|
||
)
|
||
.await
|
||
}
|
||
|
||
pub async fn list_tools(
|
||
Extension(context): Extension<RequestContext>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
ensure_authenticated(&context)?;
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(json!({
|
||
"ok": true,
|
||
"traceId": context.trace.trace_id,
|
||
"tools": [
|
||
{
|
||
"name": "mnote.page.get",
|
||
"scope": "page.read",
|
||
"kind": "read",
|
||
"schemaVersion": "mnote.hermes_tool.v1",
|
||
"status": "available",
|
||
"description": "读取当前页面正文、标题、设置与结构快照"
|
||
},
|
||
{
|
||
"name": "mnote.page.save",
|
||
"scope": "page.write",
|
||
"kind": "write",
|
||
"schemaVersion": "mnote.hermes_tool.v1",
|
||
"status": "available",
|
||
"description": "保存当前页面正文"
|
||
},
|
||
{
|
||
"name": "mnote.page.update_title",
|
||
"scope": "page.write",
|
||
"kind": "write",
|
||
"schemaVersion": "mnote.hermes_tool.v1",
|
||
"status": "available",
|
||
"description": "更新当前页面标题"
|
||
},
|
||
{
|
||
"name": "mnote.page.update_options",
|
||
"scope": "page.write",
|
||
"kind": "write",
|
||
"schemaVersion": "mnote.hermes_tool.v1",
|
||
"status": "available",
|
||
"description": "更新当前页面设置"
|
||
},
|
||
{
|
||
"name": "mnote.artifact.create_summary",
|
||
"scope": "artifact.write",
|
||
"kind": "write",
|
||
"schemaVersion": "mnote.hermes_tool.v1",
|
||
"status": "available",
|
||
"description": "为当前页面创建或更新 AI Summary"
|
||
},
|
||
{
|
||
"name": "mnote.artifact.create_ai_note",
|
||
"scope": "artifact.write",
|
||
"kind": "write",
|
||
"schemaVersion": "mnote.hermes_tool.v1",
|
||
"status": "available",
|
||
"description": "基于当前页面创建新的 AI Note"
|
||
}
|
||
]
|
||
})),
|
||
))
|
||
}
|
||
|
||
fn hermes_bin() -> String {
|
||
std::env::var("MNOTE_WEB_HERMES_BIN")
|
||
.ok()
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or_else(|| "hermes".into())
|
||
}
|
||
|
||
fn hermes_home() -> PathBuf {
|
||
std::env::var("HERMES_HOME")
|
||
.ok()
|
||
.filter(|value| !value.trim().is_empty())
|
||
.map(PathBuf::from)
|
||
.or_else(|| {
|
||
std::env::var("HOME")
|
||
.ok()
|
||
.map(|home| PathBuf::from(home).join(".hermes"))
|
||
})
|
||
.unwrap_or_else(|| PathBuf::from(".hermes"))
|
||
}
|
||
|
||
fn active_profile_name() -> Option<String> {
|
||
fs::read_to_string(hermes_home().join("active_profile"))
|
||
.ok()
|
||
.map(|value| value.trim().to_string())
|
||
.filter(|value| !value.is_empty())
|
||
}
|
||
|
||
fn profile_home(profile: &str) -> PathBuf {
|
||
let home = hermes_home();
|
||
let profile = profile.trim();
|
||
if profile.is_empty() || profile == "default" {
|
||
return home;
|
||
}
|
||
let candidate = home.join("profiles").join(profile);
|
||
if candidate.exists() {
|
||
candidate
|
||
} else {
|
||
home
|
||
}
|
||
}
|
||
|
||
fn profile_config_path(profile: &str) -> PathBuf {
|
||
profile_home(profile).join("config.yaml")
|
||
}
|
||
|
||
fn parse_profile_list(stdout: &str) -> Vec<Value> {
|
||
let active = active_profile_name().unwrap_or_else(|| "default".into());
|
||
stdout
|
||
.replace("\r\n", "\n")
|
||
.replace('\r', "\n")
|
||
.lines()
|
||
.filter_map(|line| {
|
||
let trimmed = line.trim();
|
||
if trimmed.is_empty() || trimmed.starts_with("Profile") || trimmed.starts_with('─') {
|
||
return None;
|
||
}
|
||
let is_active = trimmed.starts_with('◆');
|
||
let without_marker = trimmed.trim_start_matches('◆').trim();
|
||
let parts = without_marker
|
||
.split_whitespace()
|
||
.map(str::to_string)
|
||
.collect::<Vec<_>>();
|
||
if parts.is_empty() {
|
||
return None;
|
||
}
|
||
let name = parts[0].clone();
|
||
let model = parts
|
||
.get(1)
|
||
.filter(|value| value.as_str() != "—")
|
||
.cloned()
|
||
.unwrap_or_default();
|
||
let gateway = parts
|
||
.get(2)
|
||
.filter(|value| value.as_str() != "—")
|
||
.cloned()
|
||
.unwrap_or_default();
|
||
let alias = parts
|
||
.get(3)
|
||
.filter(|value| value.as_str() != "—")
|
||
.cloned()
|
||
.unwrap_or_default();
|
||
Some(json!({
|
||
"name": name,
|
||
"active": name == active || (active == "default" && is_active),
|
||
"model": model,
|
||
"gateway": gateway,
|
||
"alias": alias
|
||
}))
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn fallback_profiles() -> Vec<Value> {
|
||
let active = active_profile_name().unwrap_or_else(|| "default".into());
|
||
let default_status = profile_gateway_status("default");
|
||
let mut profiles = vec![json!({
|
||
"name": "default",
|
||
"active": active == "default",
|
||
"model": default_status["modelDefault"].as_str().unwrap_or_default(),
|
||
"gateway": default_status["gateway"].as_str().unwrap_or_default(),
|
||
"provider": default_status["provider"].as_str().unwrap_or_default(),
|
||
"alias": ""
|
||
})];
|
||
let profiles_dir = hermes_home().join("profiles");
|
||
if let Ok(entries) = fs::read_dir(profiles_dir) {
|
||
let mut names = entries
|
||
.filter_map(Result::ok)
|
||
.filter(|entry| entry.file_type().map(|kind| kind.is_dir()).unwrap_or(false))
|
||
.filter_map(|entry| entry.file_name().into_string().ok())
|
||
.collect::<Vec<_>>();
|
||
names.sort();
|
||
profiles.extend(names.into_iter().map(|name| {
|
||
let status = profile_gateway_status(&name);
|
||
json!({
|
||
"name": name,
|
||
"active": name == active,
|
||
"model": status["modelDefault"].as_str().unwrap_or_default(),
|
||
"gateway": status["gateway"].as_str().unwrap_or_default(),
|
||
"provider": status["provider"].as_str().unwrap_or_default(),
|
||
"alias": ""
|
||
})
|
||
}));
|
||
}
|
||
profiles
|
||
}
|
||
|
||
fn list_profiles_payload() -> Value {
|
||
let profiles = Command::new(hermes_bin())
|
||
.args(["profile", "list"])
|
||
.output()
|
||
.ok()
|
||
.filter(|output| output.status.success())
|
||
.and_then(|output| String::from_utf8(output.stdout).ok())
|
||
.map(|stdout| parse_profile_list(&stdout))
|
||
.filter(|profiles| !profiles.is_empty())
|
||
.unwrap_or_else(fallback_profiles);
|
||
json!({
|
||
"ok": true,
|
||
"profiles": profiles
|
||
})
|
||
}
|
||
|
||
fn profile_detail_payload(profile: &str) -> Value {
|
||
let dir = profile_home(profile);
|
||
let gateway_status = profile_gateway_status(profile);
|
||
json!({
|
||
"name": if profile.trim().is_empty() { "default" } else { profile.trim() },
|
||
"path": dir.to_string_lossy(),
|
||
"model": gateway_status["modelDefault"].as_str().unwrap_or_default(),
|
||
"provider": gateway_status["provider"].as_str().unwrap_or_default(),
|
||
"gateway": gateway_status["gateway"].as_str().unwrap_or_default(),
|
||
"modelConfigured": gateway_status["modelConfigured"].as_bool().unwrap_or(false),
|
||
"apiKeyConfigured": gateway_status["apiKeyConfigured"].as_bool().unwrap_or(false),
|
||
"suggestions": gateway_status["suggestions"].clone(),
|
||
"skills": skills_payload(profile)["categories"].as_array().map(Vec::len).unwrap_or_default(),
|
||
"hasEnv": dir.join(".env").exists(),
|
||
"hasSoulMd": dir.join("SOUL.md").exists()
|
||
})
|
||
}
|
||
|
||
fn switch_active_profile_local(profile: &str) -> std::io::Result<()> {
|
||
let command_result = Command::new(hermes_bin())
|
||
.args(["profile", "use", profile])
|
||
.output();
|
||
if command_result
|
||
.as_ref()
|
||
.map(|output| output.status.success())
|
||
.unwrap_or(false)
|
||
{
|
||
return Ok(());
|
||
}
|
||
let home = hermes_home();
|
||
fs::create_dir_all(&home)?;
|
||
if profile != "default" {
|
||
fs::create_dir_all(home.join("profiles").join(profile))?;
|
||
}
|
||
fs::write(home.join("active_profile"), profile.as_bytes())
|
||
}
|
||
|
||
fn file_text(path: &FsPath) -> String {
|
||
fs::read_to_string(path).unwrap_or_default()
|
||
}
|
||
|
||
fn file_mtime_ms(path: &FsPath) -> Option<i128> {
|
||
let modified = fs::metadata(path).ok()?.modified().ok()?;
|
||
let duration = modified.duration_since(std::time::UNIX_EPOCH).ok()?;
|
||
Some(duration.as_millis() as i128)
|
||
}
|
||
|
||
fn profile_memory_payload(profile: &str) -> Value {
|
||
let dir = profile_home(profile);
|
||
let memory_path = dir.join("memories").join("MEMORY.md");
|
||
let user_path = dir.join("memories").join("USER.md");
|
||
let soul_path = dir.join("SOUL.md");
|
||
json!({
|
||
"ok": true,
|
||
"memory": file_text(&memory_path),
|
||
"user": file_text(&user_path),
|
||
"soul": file_text(&soul_path),
|
||
"memory_mtime": file_mtime_ms(&memory_path),
|
||
"user_mtime": file_mtime_ms(&user_path),
|
||
"soul_mtime": file_mtime_ms(&soul_path)
|
||
})
|
||
}
|
||
|
||
fn save_profile_memory_local(profile: &str, section: &str, content: &str) -> std::io::Result<()> {
|
||
let dir = profile_home(profile);
|
||
let path = match section {
|
||
"soul" => dir.join("SOUL.md"),
|
||
"user" => dir.join("memories").join("USER.md"),
|
||
_ => dir.join("memories").join("MEMORY.md"),
|
||
};
|
||
if let Some(parent) = path.parent() {
|
||
fs::create_dir_all(parent)?;
|
||
}
|
||
fs::write(path, content)
|
||
}
|
||
|
||
fn disabled_skills(profile: &str) -> Vec<String> {
|
||
let content = fs::read_to_string(profile_config_path(profile)).unwrap_or_default();
|
||
let mut disabled = Vec::new();
|
||
let mut in_skills = false;
|
||
let mut in_disabled = false;
|
||
for line in content.lines() {
|
||
let trimmed = line.trim();
|
||
if !line.starts_with(' ') && !trimmed.is_empty() {
|
||
in_skills = trimmed == "skills:";
|
||
in_disabled = false;
|
||
continue;
|
||
}
|
||
if in_skills && trimmed == "disabled:" {
|
||
in_disabled = true;
|
||
continue;
|
||
}
|
||
if in_disabled {
|
||
if let Some(value) = trimmed.strip_prefix("- ") {
|
||
disabled.push(
|
||
value
|
||
.trim()
|
||
.trim_matches('"')
|
||
.trim_matches('\'')
|
||
.to_string(),
|
||
);
|
||
} else if !trimmed.is_empty() && !trimmed.starts_with('#') {
|
||
in_disabled = false;
|
||
}
|
||
}
|
||
}
|
||
disabled
|
||
}
|
||
|
||
fn extract_skill_description(markdown: &str) -> String {
|
||
markdown
|
||
.lines()
|
||
.find_map(|line| {
|
||
let trimmed = line.trim();
|
||
if trimmed.is_empty() || trimmed.starts_with('#') {
|
||
return None;
|
||
}
|
||
Some(
|
||
trimmed
|
||
.trim_start_matches("Description:")
|
||
.trim()
|
||
.to_string(),
|
||
)
|
||
})
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
struct SkillCatalogMeta {
|
||
bundled: HashSet<String>,
|
||
hub_installed: HashSet<String>,
|
||
usage: HashMap<String, Value>,
|
||
}
|
||
|
||
impl SkillCatalogMeta {
|
||
fn read(skills_dir: &FsPath) -> Self {
|
||
Self {
|
||
bundled: read_bundled_skill_names(&skills_dir.join(".bundled_manifest")),
|
||
hub_installed: read_hub_installed_skill_names(
|
||
&skills_dir.join(".hub").join("lock.json"),
|
||
),
|
||
usage: read_skill_usage(&skills_dir.join(".usage.json")),
|
||
}
|
||
}
|
||
|
||
fn usage_for(&self, name: &str) -> Option<&Value> {
|
||
self.usage.get(name)
|
||
}
|
||
}
|
||
|
||
fn read_bundled_skill_names(path: &FsPath) -> HashSet<String> {
|
||
fs::read_to_string(path)
|
||
.ok()
|
||
.map(|content| {
|
||
content
|
||
.lines()
|
||
.filter_map(|line| {
|
||
line.split_once(':')
|
||
.map(|(name, _)| name.trim().to_string())
|
||
})
|
||
.filter(|name| !name.is_empty())
|
||
.collect()
|
||
})
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn read_hub_installed_skill_names(path: &FsPath) -> HashSet<String> {
|
||
let Ok(content) = fs::read_to_string(path) else {
|
||
return HashSet::new();
|
||
};
|
||
let Ok(payload) = serde_json::from_str::<Value>(&content) else {
|
||
return HashSet::new();
|
||
};
|
||
payload
|
||
.get("installed")
|
||
.and_then(Value::as_object)
|
||
.map(|installed| {
|
||
installed
|
||
.iter()
|
||
.flat_map(|(name, entry)| {
|
||
let mut names = vec![name.to_string()];
|
||
if let Some(path) = entry.get("install_path").and_then(Value::as_str) {
|
||
if let Some(last) = path.rsplit('/').find(|part| !part.trim().is_empty()) {
|
||
names.push(last.to_string());
|
||
}
|
||
}
|
||
names
|
||
})
|
||
.collect()
|
||
})
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn read_skill_usage(path: &FsPath) -> HashMap<String, Value> {
|
||
let Ok(content) = fs::read_to_string(path) else {
|
||
return HashMap::new();
|
||
};
|
||
serde_json::from_str::<Value>(&content)
|
||
.ok()
|
||
.and_then(|payload| payload.as_object().cloned())
|
||
.map(|items| items.into_iter().collect())
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn skill_source(name: &str, meta: &SkillCatalogMeta) -> &'static str {
|
||
if meta.bundled.contains(name) {
|
||
"builtin"
|
||
} else if meta.hub_installed.contains(name) {
|
||
"hub"
|
||
} else {
|
||
"local"
|
||
}
|
||
}
|
||
|
||
fn skill_is_agent_generated(usage: Option<&Value>) -> bool {
|
||
usage
|
||
.and_then(Value::as_object)
|
||
.map(|record| {
|
||
record
|
||
.get("created_by")
|
||
.and_then(Value::as_str)
|
||
.map(|value| value == "agent")
|
||
.unwrap_or(false)
|
||
|| record
|
||
.get("agent_created")
|
||
.and_then(Value::as_bool)
|
||
.unwrap_or(false)
|
||
})
|
||
.unwrap_or(false)
|
||
}
|
||
|
||
fn skill_origin(source: &str, usage: Option<&Value>) -> &'static str {
|
||
if skill_is_agent_generated(usage) {
|
||
"generated"
|
||
} else if source == "builtin" {
|
||
"builtin"
|
||
} else if source == "hub" {
|
||
"installed"
|
||
} else {
|
||
"copied"
|
||
}
|
||
}
|
||
|
||
fn skill_entry(
|
||
name: String,
|
||
category: String,
|
||
path: PathBuf,
|
||
disabled: &[String],
|
||
meta: &SkillCatalogMeta,
|
||
) -> Option<Value> {
|
||
let content = fs::read_to_string(path).ok()?;
|
||
let source = skill_source(&name, meta);
|
||
let usage = meta.usage_for(&name);
|
||
Some(json!({
|
||
"name": name,
|
||
"description": extract_skill_description(&content),
|
||
"enabled": !disabled.iter().any(|item| item == &name),
|
||
"source": source,
|
||
"origin": skill_origin(source, usage),
|
||
"createdBy": usage.and_then(|record| record.get("created_by")).and_then(Value::as_str),
|
||
"createdAt": usage.and_then(|record| record.get("created_at")).and_then(Value::as_str),
|
||
"patchCount": usage.and_then(|record| record.get("patch_count")).and_then(Value::as_i64),
|
||
"category": category
|
||
}))
|
||
}
|
||
|
||
fn skills_payload(profile: &str) -> Value {
|
||
let skills_dir = hermes_home().join("skills");
|
||
let disabled = disabled_skills(profile);
|
||
let meta = SkillCatalogMeta::read(&skills_dir);
|
||
let mut categories = Vec::new();
|
||
let Ok(entries) = fs::read_dir(&skills_dir) else {
|
||
return json!({"ok": true, "categories": [], "archived": []});
|
||
};
|
||
let mut dirs = entries
|
||
.filter_map(Result::ok)
|
||
.filter(|entry| entry.file_type().map(|kind| kind.is_dir()).unwrap_or(false))
|
||
.filter(|entry| !entry.file_name().to_string_lossy().starts_with('.'))
|
||
.collect::<Vec<_>>();
|
||
dirs.sort_by_key(|entry| entry.file_name());
|
||
for entry in dirs {
|
||
let name = entry.file_name().to_string_lossy().to_string();
|
||
let dir = entry.path();
|
||
let direct_skill = dir.join("SKILL.md");
|
||
if direct_skill.exists() {
|
||
if let Some(skill) = skill_entry(name, "misc".into(), direct_skill, &disabled, &meta) {
|
||
categories.push(json!({
|
||
"name": "misc",
|
||
"description": "misc",
|
||
"skills": [skill]
|
||
}));
|
||
}
|
||
continue;
|
||
}
|
||
let mut skills = fs::read_dir(&dir)
|
||
.ok()
|
||
.into_iter()
|
||
.flat_map(|entries| entries.filter_map(Result::ok))
|
||
.filter(|child| child.file_type().map(|kind| kind.is_dir()).unwrap_or(false))
|
||
.filter_map(|child| {
|
||
let skill_name = child.file_name().to_string_lossy().to_string();
|
||
skill_entry(
|
||
skill_name,
|
||
name.clone(),
|
||
child.path().join("SKILL.md"),
|
||
&disabled,
|
||
&meta,
|
||
)
|
||
})
|
||
.collect::<Vec<_>>();
|
||
if !skills.is_empty() {
|
||
skills.sort_by_key(|skill| skill["name"].as_str().unwrap_or_default().to_string());
|
||
categories.push(json!({
|
||
"name": name,
|
||
"description": "",
|
||
"skills": skills
|
||
}));
|
||
}
|
||
}
|
||
json!({
|
||
"ok": true,
|
||
"categories": merge_misc_categories(categories),
|
||
"archived": []
|
||
})
|
||
}
|
||
|
||
fn merge_misc_categories(categories: Vec<Value>) -> Vec<Value> {
|
||
let mut merged = Vec::new();
|
||
let mut misc = Vec::new();
|
||
for category in categories {
|
||
if category["name"].as_str() == Some("misc") {
|
||
if let Some(skills) = category["skills"].as_array() {
|
||
misc.extend(skills.iter().cloned());
|
||
}
|
||
} else {
|
||
merged.push(category);
|
||
}
|
||
}
|
||
if !misc.is_empty() {
|
||
misc.sort_by_key(|skill| skill["name"].as_str().unwrap_or_default().to_string());
|
||
merged.insert(
|
||
0,
|
||
json!({
|
||
"name": "misc",
|
||
"description": "misc",
|
||
"skills": misc
|
||
}),
|
||
);
|
||
}
|
||
merged
|
||
}
|
||
|
||
fn set_skill_enabled(profile: &str, name: &str, enabled: bool) -> std::io::Result<()> {
|
||
let path = profile_config_path(profile);
|
||
let mut disabled = disabled_skills(profile);
|
||
if enabled {
|
||
disabled.retain(|item| item != name);
|
||
} else if !disabled.iter().any(|item| item == name) {
|
||
disabled.push(name.to_string());
|
||
}
|
||
disabled.sort();
|
||
let existing = fs::read_to_string(&path).unwrap_or_default();
|
||
let mut kept = Vec::new();
|
||
let mut in_skills = false;
|
||
let mut in_disabled = false;
|
||
for line in existing.lines() {
|
||
let trimmed = line.trim();
|
||
if !line.starts_with(' ') && !trimmed.is_empty() {
|
||
in_skills = trimmed == "skills:";
|
||
in_disabled = false;
|
||
}
|
||
if in_skills && trimmed == "disabled:" {
|
||
in_disabled = true;
|
||
continue;
|
||
}
|
||
if in_disabled {
|
||
if trimmed.starts_with("- ") || trimmed.is_empty() {
|
||
continue;
|
||
}
|
||
in_disabled = false;
|
||
}
|
||
kept.push(line.to_string());
|
||
}
|
||
if let Some(parent) = path.parent() {
|
||
fs::create_dir_all(parent)?;
|
||
}
|
||
let mut output = kept.join("\n");
|
||
if !output.ends_with('\n') && !output.is_empty() {
|
||
output.push('\n');
|
||
}
|
||
output.push_str("skills:\n disabled:\n");
|
||
for skill in disabled {
|
||
output.push_str(" - ");
|
||
output.push_str(&skill);
|
||
output.push('\n');
|
||
}
|
||
fs::write(path, output)
|
||
}
|
||
|
||
fn ensure_authenticated(context: &RequestContext) -> Result<(), WebError> {
|
||
let has_actor = context.auth.actor_id.trim() != "anonymous";
|
||
if has_actor || context.auth.authorization.is_some() || context.auth.cookie_header.is_some() {
|
||
return Ok(());
|
||
}
|
||
Err(WebError::new(
|
||
StatusCode::UNAUTHORIZED,
|
||
"hermes_client_unauthorized",
|
||
"页面 AI Hermes client 需要登录后访问",
|
||
)
|
||
.with_context(context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client"))
|
||
}
|
||
|
||
fn configured_upstream() -> Option<String> {
|
||
[
|
||
"MNOTE_WEB_HERMES_UPSTREAM_URL",
|
||
"MNOTE_HERMES_UPSTREAM_URL",
|
||
"MNOTE_HERMES_API_BASE_URL",
|
||
]
|
||
.into_iter()
|
||
.find_map(env_or_dotenv)
|
||
.map(|value| value.trim().trim_end_matches('/').to_string())
|
||
.filter(|value| !value.is_empty())
|
||
}
|
||
|
||
fn configured_api_key() -> Option<String> {
|
||
[
|
||
"MNOTE_WEB_HERMES_API_KEY",
|
||
"MNOTE_HERMES_API_KEY",
|
||
"HERMES_API_SERVER_KEY",
|
||
"API_SERVER_KEY",
|
||
]
|
||
.into_iter()
|
||
.find_map(env_or_dotenv)
|
||
.map(|value| value.trim().to_string())
|
||
.filter(|value| !value.is_empty())
|
||
}
|
||
|
||
#[derive(Debug)]
|
||
struct GatewayProbe {
|
||
ok: bool,
|
||
status: String,
|
||
http_status: Option<u64>,
|
||
path: Option<String>,
|
||
message: Option<String>,
|
||
}
|
||
|
||
async fn probe_gateway_health(upstream: &str) -> GatewayProbe {
|
||
let client = match reqwest::Client::builder()
|
||
.timeout(Duration::from_secs(3))
|
||
.build()
|
||
{
|
||
Ok(client) => client,
|
||
Err(error) => {
|
||
return GatewayProbe {
|
||
ok: false,
|
||
status: "client_error".into(),
|
||
http_status: None,
|
||
path: None,
|
||
message: Some(format!("Hermes gateway health client 构造失败: {error}")),
|
||
};
|
||
}
|
||
};
|
||
for path in ["/health", "/v1/models"] {
|
||
let Ok(url) = upstream_url(upstream, path) else {
|
||
continue;
|
||
};
|
||
let mut request = client.get(url);
|
||
if let Some(api_key) = configured_api_key() {
|
||
request = request.bearer_auth(api_key);
|
||
}
|
||
match request.send().await {
|
||
Ok(response) if response.status().is_success() => {
|
||
return GatewayProbe {
|
||
ok: true,
|
||
status: "ok".into(),
|
||
http_status: Some(response.status().as_u16() as u64),
|
||
path: Some(path.into()),
|
||
message: None,
|
||
};
|
||
}
|
||
Ok(response) => {
|
||
let status = response.status();
|
||
let text = response.text().await.unwrap_or_default();
|
||
if path == "/v1/models" || status != reqwest::StatusCode::NOT_FOUND {
|
||
return GatewayProbe {
|
||
ok: false,
|
||
status: "upstream_error".into(),
|
||
http_status: Some(status.as_u16() as u64),
|
||
path: Some(path.into()),
|
||
message: Some(text.chars().take(600).collect()),
|
||
};
|
||
}
|
||
}
|
||
Err(error) => {
|
||
return GatewayProbe {
|
||
ok: false,
|
||
status: "unreachable".into(),
|
||
http_status: None,
|
||
path: Some(path.into()),
|
||
message: Some(error.to_string()),
|
||
};
|
||
}
|
||
}
|
||
}
|
||
GatewayProbe {
|
||
ok: false,
|
||
status: "unknown".into(),
|
||
http_status: None,
|
||
path: None,
|
||
message: Some("Hermes gateway health 探测未返回有效结果".into()),
|
||
}
|
||
}
|
||
|
||
fn env_or_dotenv(key: &str) -> Option<String> {
|
||
if let Ok(value) = std::env::var(key) {
|
||
let trimmed = value.trim().trim_matches('"').to_string();
|
||
if !trimmed.is_empty() {
|
||
return Some(trimmed);
|
||
}
|
||
}
|
||
if cfg!(test) {
|
||
return None;
|
||
}
|
||
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
|
||
.join("../../..")
|
||
.join(".env.all");
|
||
let content = fs::read_to_string(root).ok()?;
|
||
for line in content.lines() {
|
||
let line = line.trim_end_matches('\r');
|
||
if line.starts_with('#') || line.trim().is_empty() {
|
||
continue;
|
||
}
|
||
let Some((candidate_key, value)) = line.split_once('=') else {
|
||
continue;
|
||
};
|
||
if candidate_key.trim() != key {
|
||
continue;
|
||
}
|
||
let trimmed = value.trim().trim_matches('"').to_string();
|
||
if !trimmed.is_empty() {
|
||
return Some(trimmed);
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
fn yaml_path_value(content: &str, path: &[&str]) -> Option<String> {
|
||
let mut stack: Vec<(usize, String)> = Vec::new();
|
||
for raw_line in content.lines() {
|
||
let line = raw_line.trim_end_matches('\r');
|
||
let trimmed = line.trim();
|
||
if trimmed.is_empty() || trimmed.starts_with('#') || !line.contains(':') {
|
||
continue;
|
||
}
|
||
let indent = line.chars().take_while(|ch| ch.is_whitespace()).count();
|
||
while stack
|
||
.last()
|
||
.map(|(level, _)| *level >= indent)
|
||
.unwrap_or(false)
|
||
{
|
||
stack.pop();
|
||
}
|
||
let Some((key, value)) = trimmed.split_once(':') else {
|
||
continue;
|
||
};
|
||
let key = key.trim().trim_matches('"').trim_matches('\'').to_string();
|
||
let value = value
|
||
.trim()
|
||
.trim_matches('"')
|
||
.trim_matches('\'')
|
||
.to_string();
|
||
stack.push((indent, key));
|
||
let keys = stack
|
||
.iter()
|
||
.map(|(_, key)| key.as_str())
|
||
.collect::<Vec<_>>();
|
||
if keys == path && !value.is_empty() {
|
||
return Some(value);
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
fn profile_gateway_status(profile: &str) -> Value {
|
||
let normalized_profile = if profile.trim().is_empty() {
|
||
"default"
|
||
} else {
|
||
profile.trim()
|
||
};
|
||
let config_path = profile_config_path(normalized_profile);
|
||
let config = fs::read_to_string(&config_path).unwrap_or_default();
|
||
let model_default = yaml_path_value(&config, &["model", "default"]).unwrap_or_default();
|
||
let provider = yaml_path_value(&config, &["model", "provider"]).unwrap_or_default();
|
||
let gateway = yaml_path_value(&config, &["model", "gateway"])
|
||
.or_else(|| yaml_path_value(&config, &["model", "base_url"]))
|
||
.unwrap_or_default();
|
||
let model_api_key = yaml_path_value(&config, &["model", "api_key"]);
|
||
let model_key_env = yaml_path_value(&config, &["model", "key_env"]);
|
||
let provider_api_key = if provider.is_empty() {
|
||
None
|
||
} else {
|
||
yaml_path_value(&config, &["providers", &provider, "api_key"])
|
||
};
|
||
let provider_key_env = if provider.is_empty() {
|
||
None
|
||
} else {
|
||
yaml_path_value(&config, &["providers", &provider, "key_env"])
|
||
};
|
||
let key_env_configured = model_key_env
|
||
.as_deref()
|
||
.or(provider_key_env.as_deref())
|
||
.and_then(env_or_dotenv)
|
||
.is_some();
|
||
let api_key_configured = model_api_key
|
||
.as_deref()
|
||
.or(provider_api_key.as_deref())
|
||
.map(|value| !value.trim().is_empty())
|
||
.unwrap_or(false)
|
||
|| key_env_configured;
|
||
let mut suggestions = Vec::new();
|
||
if model_default.is_empty() {
|
||
suggestions
|
||
.push("当前 Hermes profile 缺少 model.default，请在 Hermes 设置中选择默认模型。");
|
||
}
|
||
if provider.is_empty() {
|
||
suggestions
|
||
.push("当前 Hermes profile 缺少 model.provider，请在 Hermes 设置中选择 provider。");
|
||
}
|
||
if !api_key_configured {
|
||
suggestions.push("当前 Hermes profile 未检测到 provider API key 或 key_env，请在 Hermes 设置中补齐 API key。");
|
||
}
|
||
json!({
|
||
"name": normalized_profile,
|
||
"path": profile_home(normalized_profile).to_string_lossy(),
|
||
"configPath": config_path.to_string_lossy(),
|
||
"configExists": config_path.exists(),
|
||
"modelDefault": model_default,
|
||
"provider": provider,
|
||
"gateway": gateway,
|
||
"modelConfigured": !model_default.is_empty(),
|
||
"apiKeyConfigured": api_key_configured,
|
||
"suggestions": suggestions
|
||
})
|
||
}
|
||
|
||
fn unique_string_values(values: Vec<Value>) -> Vec<Value> {
|
||
let mut seen = HashSet::new();
|
||
values
|
||
.into_iter()
|
||
.filter_map(|value| value.as_str().map(str::trim).map(ToOwned::to_owned))
|
||
.filter(|value| !value.is_empty())
|
||
.filter(|value| seen.insert(value.clone()))
|
||
.map(Value::String)
|
||
.collect()
|
||
}
|
||
|
||
fn hermes_settings_suggestions(status: Option<u64>, message: Option<&str>) -> Vec<String> {
|
||
let lower = message.unwrap_or_default().to_lowercase();
|
||
let mut suggestions = Vec::new();
|
||
if lower.contains("model.default")
|
||
|| (lower.contains("model") && (lower.contains("default") || lower.contains("missing")))
|
||
{
|
||
suggestions.push(
|
||
"当前 Hermes profile 可能缺少 model.default，请在 Hermes 设置中选择默认模型。".into(),
|
||
);
|
||
}
|
||
if lower.contains("api key")
|
||
|| lower.contains("apikey")
|
||
|| lower.contains("unauthorized")
|
||
|| lower.contains("forbidden")
|
||
|| matches!(status, Some(401 | 403))
|
||
{
|
||
suggestions.push("当前 Hermes provider 可能缺少 API key 或 key_env 未生效，请在 Hermes 设置中补齐 API key。".into());
|
||
}
|
||
if lower.contains("profile") || lower.contains("provider") {
|
||
suggestions
|
||
.push("请检查当前页面 AI 选择的 Hermes profile、provider 与 gateway 是否匹配。".into());
|
||
}
|
||
if suggestions.is_empty() {
|
||
suggestions.push("请检查 Hermes gateway 是否正在运行，并确认当前 profile 的 model.default、provider 与 API key 已配置。".into());
|
||
}
|
||
suggestions
|
||
}
|
||
|
||
fn build_run_upstream_body(context: &RequestContext, payload: Value) -> Result<Value, WebError> {
|
||
let message = extract_run_message(&payload).ok_or_else(|| {
|
||
WebError::bad_request_code("hermes_client_bad_request", "缺少 message")
|
||
.with_context(context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
let document_id = payload
|
||
.get("documentId")
|
||
.and_then(Value::as_str)
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or("current");
|
||
let trace_id = payload
|
||
.get("traceId")
|
||
.and_then(Value::as_str)
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or(&context.trace.trace_id);
|
||
let session_id = payload
|
||
.get("sessionId")
|
||
.and_then(Value::as_str)
|
||
.filter(|value| !value.trim().is_empty())
|
||
.map(ToOwned::to_owned)
|
||
.unwrap_or_else(|| stable_session_id(document_id, trace_id));
|
||
|
||
let page_context = payload.get("pageContext").cloned().unwrap_or(Value::Null);
|
||
let workspace_id = payload.get("workspaceId").cloned().unwrap_or(Value::Null);
|
||
let profile = payload
|
||
.get("profile")
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty());
|
||
let instructions = json!({
|
||
"role": "mnote_page_ai_context",
|
||
"workspaceId": workspace_id,
|
||
"documentId": document_id,
|
||
"profile": profile.unwrap_or("default"),
|
||
"actorId": payload.get("actorId").and_then(Value::as_str).unwrap_or(&context.auth.actor_id),
|
||
"actorType": payload.get("actorType").and_then(Value::as_str).unwrap_or(&context.auth.actor_type),
|
||
"sessionId": session_id,
|
||
"traceId": trace_id,
|
||
"toolGuidance": "调用 mnote_page_get / mnote_page_save / mnote.page.* 对应工具时，必须透传 workspaceId、documentId、actorId、sessionId 和 traceId；读取页面标题或页面设置时调用 mnote_page_get，并传 includeBody=false、includeOptions=true、includeBlocks=false；需要正文摘要时才传 includeBody=true。写入正文时如需追加使用 mnote_page_save mode=append，覆盖全文才使用 mode=replace。不要只依据 pageContext 猜测。",
|
||
"selectedBlockId": payload.get("selectedBlockId").cloned().unwrap_or(Value::Null),
|
||
"selectedText": payload.get("selectedText").cloned().unwrap_or(Value::Null),
|
||
"pageContext": sanitize_run_page_context(page_context)
|
||
})
|
||
.to_string();
|
||
|
||
let mut body = json!({
|
||
"input": message,
|
||
"session_id": session_id,
|
||
"instructions": instructions
|
||
});
|
||
if let Some(model) = payload
|
||
.get("model")
|
||
.and_then(Value::as_str)
|
||
.filter(|value| !value.trim().is_empty())
|
||
{
|
||
body["model"] = Value::String(model.to_string());
|
||
}
|
||
if let Some(profile) = profile {
|
||
body["profile"] = Value::String(profile.to_string());
|
||
}
|
||
Ok(body)
|
||
}
|
||
|
||
fn effective_run_actor(state: &AppState, context: &RequestContext) -> (String, String) {
|
||
let actor_id = context.auth.actor_id.trim();
|
||
if !actor_id.is_empty() && actor_id != "anonymous" {
|
||
return (actor_id.to_string(), context.auth.actor_type.clone());
|
||
}
|
||
if context.auth.authorization.is_some() || context.auth.cookie_header.is_some() {
|
||
return (state.config().dev_user_id.clone(), "devFallback".into());
|
||
}
|
||
("anonymous".into(), "anonymous".into())
|
||
}
|
||
|
||
async fn resolve_run_actor(state: &AppState, context: &RequestContext) -> (String, String) {
|
||
let actor_id = context.auth.actor_id.trim();
|
||
if !actor_id.is_empty() && actor_id != "anonymous" {
|
||
return (actor_id.to_string(), context.auth.actor_type.clone());
|
||
}
|
||
if context.auth.authorization.is_none() && context.auth.cookie_header.is_none() {
|
||
return ("anonymous".into(), "anonymous".into());
|
||
}
|
||
if let Ok(Some(user_id)) = resolve_current_convex_user_id(state, context).await {
|
||
return (user_id, "user".into());
|
||
}
|
||
effective_run_actor(state, context)
|
||
}
|
||
|
||
async fn resolve_current_convex_user_id(
|
||
state: &AppState,
|
||
context: &RequestContext,
|
||
) -> Result<Option<String>, WebError> {
|
||
let payload = execute_convex_query_by_name(
|
||
state.config(),
|
||
context,
|
||
"users:currentUser",
|
||
json!({}),
|
||
None,
|
||
"hermes_run_current_user",
|
||
)
|
||
.await?;
|
||
Ok(payload
|
||
.get("_id")
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.map(ToOwned::to_owned))
|
||
}
|
||
|
||
fn stamp_run_actor(payload: &mut Value, actor_id: &str, actor_type: &str) {
|
||
let Value::Object(map) = payload else {
|
||
return;
|
||
};
|
||
map.insert("actorId".into(), Value::String(actor_id.to_string()));
|
||
map.insert("actorType".into(), Value::String(actor_type.to_string()));
|
||
}
|
||
|
||
fn sanitize_run_page_context(page_context: Value) -> Value {
|
||
let Some(source) = page_context.as_object() else {
|
||
return Value::Null;
|
||
};
|
||
let mut sanitized = serde_json::Map::new();
|
||
for key in [
|
||
"contextScope",
|
||
"node",
|
||
"pageSubtreeSource",
|
||
"evidence",
|
||
"pageOptions",
|
||
"contentAccess",
|
||
] {
|
||
if let Some(value) = source.get(key) {
|
||
sanitized.insert(key.to_string(), value.clone());
|
||
}
|
||
}
|
||
sanitized.insert(
|
||
"contentAccess".to_string(),
|
||
sanitized
|
||
.get("contentAccess")
|
||
.cloned()
|
||
.unwrap_or_else(|| Value::String("mnote.page.get".into())),
|
||
);
|
||
Value::Object(sanitized)
|
||
}
|
||
|
||
fn now_ms() -> u128 {
|
||
SystemTime::now()
|
||
.duration_since(UNIX_EPOCH)
|
||
.map(|duration| duration.as_millis())
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn runtime_state_to_json(state: &HermesRuntimeState) -> Value {
|
||
json!({
|
||
"sessionId": state.session_id,
|
||
"runId": state.run_id,
|
||
"profile": state.profile,
|
||
"documentId": state.document_id,
|
||
"traceId": state.trace_id,
|
||
"status": state.status,
|
||
"startedAt": state.started_at,
|
||
"lastEventAt": state.last_event_at,
|
||
"lastEvent": state.last_event,
|
||
"lastToolName": state.last_tool_name,
|
||
"lastToolCallId": state.last_tool_call_id,
|
||
"lastAuditId": state.last_audit_id
|
||
})
|
||
}
|
||
|
||
fn runtime_state_for_session(session_id: &str) -> Value {
|
||
let registry = HERMES_RUNTIME_REGISTRY
|
||
.lock()
|
||
.expect("hermes runtime registry");
|
||
registry
|
||
.get(session_id)
|
||
.map(runtime_state_to_json)
|
||
.unwrap_or(Value::Null)
|
||
}
|
||
|
||
fn runtime_state_for_run(run_id: &str) -> Option<Value> {
|
||
let registry = HERMES_RUNTIME_REGISTRY
|
||
.lock()
|
||
.expect("hermes runtime registry");
|
||
registry
|
||
.values()
|
||
.find(|state| state.run_id == run_id)
|
||
.map(runtime_state_to_json)
|
||
}
|
||
|
||
fn run_registration_from_payload(
|
||
context: &RequestContext,
|
||
payload: &Value,
|
||
) -> HermesRunRegistration {
|
||
let document_id = payload
|
||
.get("documentId")
|
||
.and_then(Value::as_str)
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or("current")
|
||
.to_string();
|
||
let trace_id = payload
|
||
.get("traceId")
|
||
.and_then(Value::as_str)
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or(&context.trace.trace_id)
|
||
.to_string();
|
||
let session_id = payload
|
||
.get("sessionId")
|
||
.and_then(Value::as_str)
|
||
.filter(|value| !value.trim().is_empty())
|
||
.map(ToOwned::to_owned)
|
||
.unwrap_or_else(|| stable_session_id(&document_id, &trace_id));
|
||
let profile = payload
|
||
.get("profile")
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.unwrap_or("default")
|
||
.to_string();
|
||
HermesRunRegistration {
|
||
session_id,
|
||
profile,
|
||
document_id,
|
||
trace_id,
|
||
}
|
||
}
|
||
|
||
fn register_runtime_from_create_run_response(
|
||
registration: &HermesRunRegistration,
|
||
payload: &Value,
|
||
) -> Option<Value> {
|
||
let upstream = payload.get("upstream").unwrap_or(payload);
|
||
let run_id = upstream
|
||
.get("run_id")
|
||
.or_else(|| upstream.get("runId"))
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())?
|
||
.to_string();
|
||
let now = now_ms();
|
||
let state = HermesRuntimeState {
|
||
session_id: registration.session_id.clone(),
|
||
run_id,
|
||
profile: registration.profile.clone(),
|
||
document_id: registration.document_id.clone(),
|
||
trace_id: registration.trace_id.clone(),
|
||
status: "running".into(),
|
||
started_at: now,
|
||
last_event_at: now,
|
||
last_event: Some("run.started".into()),
|
||
last_tool_name: None,
|
||
last_tool_call_id: None,
|
||
last_audit_id: None,
|
||
};
|
||
let json = runtime_state_to_json(&state);
|
||
HERMES_RUNTIME_REGISTRY
|
||
.lock()
|
||
.expect("hermes runtime registry")
|
||
.insert(registration.session_id.clone(), state);
|
||
Some(json)
|
||
}
|
||
|
||
fn update_runtime_by_run_id(
|
||
run_id: &str,
|
||
status: &str,
|
||
event: Option<&str>,
|
||
tool: Option<(Option<String>, Option<String>, Option<String>)>,
|
||
) {
|
||
let mut registry = HERMES_RUNTIME_REGISTRY
|
||
.lock()
|
||
.expect("hermes runtime registry");
|
||
let Some(state) = registry.values_mut().find(|state| state.run_id == run_id) else {
|
||
return;
|
||
};
|
||
state.status = status.to_string();
|
||
state.last_event_at = now_ms();
|
||
if let Some(event) = event {
|
||
state.last_event = Some(event.to_string());
|
||
}
|
||
if let Some((tool_name, tool_call_id, audit_id)) = tool {
|
||
if let Some(tool_name) = tool_name {
|
||
state.last_tool_name = Some(tool_name);
|
||
}
|
||
if let Some(tool_call_id) = tool_call_id {
|
||
state.last_tool_call_id = Some(tool_call_id);
|
||
}
|
||
if let Some(audit_id) = audit_id {
|
||
state.last_audit_id = Some(audit_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
fn normalize_sse_chunk(run_id: &str, chunk: &str) -> (String, Vec<String>) {
|
||
let events = sse_json_events(chunk);
|
||
let terminal_sessions = update_runtime_from_events(run_id, &events);
|
||
let mut output = String::new();
|
||
for event in events {
|
||
let normalized = normalize_runtime_event(run_id, event);
|
||
let event_name = normalized
|
||
.get("event")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or("runtime.event");
|
||
output.push_str("event: ");
|
||
output.push_str(event_name);
|
||
output.push_str("\ndata: ");
|
||
output.push_str(&normalized.to_string());
|
||
output.push_str("\n\n");
|
||
}
|
||
if output.is_empty() {
|
||
output.push_str(chunk);
|
||
}
|
||
(output, terminal_sessions)
|
||
}
|
||
|
||
fn update_runtime_from_events(run_id: &str, events: &[Value]) -> Vec<String> {
|
||
let mut terminal_sessions = Vec::new();
|
||
for event in events {
|
||
let event_name = canonical_event_name(event);
|
||
if event_name.is_empty() {
|
||
continue;
|
||
}
|
||
let next_status = match event_name.as_str() {
|
||
"tool.started" => "tool_calling",
|
||
"tool.completed" | "tool.failed" => "running",
|
||
"run.completed" => "completed",
|
||
"run.failed" => "failed",
|
||
"run.aborted" => "aborted",
|
||
_ => "running",
|
||
};
|
||
let tool = if event_name.starts_with("tool.") {
|
||
Some((
|
||
event
|
||
.get("name")
|
||
.or_else(|| event.get("tool"))
|
||
.or_else(|| event.get("toolName"))
|
||
.and_then(Value::as_str)
|
||
.map(ToOwned::to_owned),
|
||
event
|
||
.get("tool_call_id")
|
||
.or_else(|| event.get("toolCallId"))
|
||
.or_else(|| event.get("id"))
|
||
.and_then(Value::as_str)
|
||
.map(ToOwned::to_owned),
|
||
event
|
||
.get("audit_id")
|
||
.or_else(|| event.get("auditId"))
|
||
.and_then(Value::as_str)
|
||
.map(ToOwned::to_owned),
|
||
))
|
||
} else {
|
||
None
|
||
};
|
||
update_runtime_by_run_id(run_id, next_status, Some(&event_name), tool);
|
||
if matches!(next_status, "completed" | "failed" | "aborted") {
|
||
if let Some(session_id) = session_id_for_run(run_id) {
|
||
terminal_sessions.push(session_id);
|
||
}
|
||
}
|
||
}
|
||
terminal_sessions
|
||
}
|
||
|
||
fn canonical_event_name(event: &Value) -> String {
|
||
let raw = event
|
||
.get("event")
|
||
.and_then(Value::as_str)
|
||
.or_else(|| event.get("type").and_then(Value::as_str))
|
||
.unwrap_or_default();
|
||
match raw {
|
||
"assistant_message" | "response.output_text.delta" => "message.delta",
|
||
"response.completed" => "run.completed",
|
||
"response.failed" => "run.failed",
|
||
"run.cancelled" | "run.canceled" | "abort.completed" => "run.aborted",
|
||
value => value,
|
||
}
|
||
.to_string()
|
||
}
|
||
|
||
fn normalize_runtime_event(run_id: &str, event: Value) -> Value {
|
||
let event_name = canonical_event_name(&event);
|
||
let session_id = event
|
||
.get("session_id")
|
||
.or_else(|| event.get("sessionId"))
|
||
.and_then(Value::as_str)
|
||
.map(ToOwned::to_owned)
|
||
.or_else(|| session_id_for_run(run_id));
|
||
let trace_id = event
|
||
.get("trace_id")
|
||
.or_else(|| event.get("traceId"))
|
||
.and_then(Value::as_str)
|
||
.unwrap_or_default();
|
||
let mut normalized = json!({
|
||
"schemaVersion": "mnote.hermes_runtime_event.v1",
|
||
"event": event_name,
|
||
"runId": event.get("run_id").or_else(|| event.get("runId")).and_then(Value::as_str).unwrap_or(run_id),
|
||
"sessionId": session_id,
|
||
"traceId": trace_id,
|
||
"upstream": event
|
||
});
|
||
if event_name == "message.delta" {
|
||
normalized["delta"] = event
|
||
.get("delta")
|
||
.or_else(|| event.get("text"))
|
||
.or_else(|| event.get("output_text"))
|
||
.cloned()
|
||
.unwrap_or(Value::Null);
|
||
}
|
||
if event_name.starts_with("tool.") {
|
||
normalized["toolName"] = event
|
||
.get("name")
|
||
.or_else(|| event.get("tool"))
|
||
.or_else(|| event.get("toolName"))
|
||
.cloned()
|
||
.unwrap_or(Value::Null);
|
||
normalized["toolCallId"] = event
|
||
.get("tool_call_id")
|
||
.or_else(|| event.get("toolCallId"))
|
||
.or_else(|| event.get("id"))
|
||
.cloned()
|
||
.unwrap_or(Value::Null);
|
||
normalized["args"] = event
|
||
.get("arguments")
|
||
.or_else(|| event.get("args"))
|
||
.or_else(|| event.get("input"))
|
||
.cloned()
|
||
.unwrap_or(Value::Null);
|
||
normalized["summary"] = event
|
||
.get("summary")
|
||
.or_else(|| event.get("result"))
|
||
.or_else(|| event.get("output"))
|
||
.cloned()
|
||
.unwrap_or(Value::Null);
|
||
normalized["code"] = event.get("code").cloned().unwrap_or(Value::Null);
|
||
normalized["error"] = event.get("error").cloned().unwrap_or(Value::Null);
|
||
normalized["auditId"] = event
|
||
.get("audit_id")
|
||
.or_else(|| event.get("auditId"))
|
||
.cloned()
|
||
.unwrap_or(Value::Null);
|
||
}
|
||
if event_name == "run.completed" {
|
||
normalized["output"] = event.get("output").cloned().unwrap_or(Value::Null);
|
||
normalized["usage"] = event.get("usage").cloned().unwrap_or(Value::Null);
|
||
}
|
||
if event_name == "run.failed" {
|
||
normalized["code"] = event.get("code").cloned().unwrap_or(Value::Null);
|
||
normalized["message"] = event
|
||
.get("message")
|
||
.or_else(|| event.get("error"))
|
||
.cloned()
|
||
.unwrap_or(Value::Null);
|
||
}
|
||
normalized
|
||
}
|
||
|
||
fn session_id_for_run(run_id: &str) -> Option<String> {
|
||
let registry = HERMES_RUNTIME_REGISTRY
|
||
.lock()
|
||
.expect("hermes runtime registry");
|
||
registry
|
||
.values()
|
||
.find(|state| state.run_id == run_id)
|
||
.map(|state| state.session_id.clone())
|
||
}
|
||
|
||
fn sse_json_events(chunk: &str) -> Vec<Value> {
|
||
chunk
|
||
.split("\n\n")
|
||
.filter_map(|block| {
|
||
let data = block
|
||
.lines()
|
||
.filter_map(|line| line.strip_prefix("data:"))
|
||
.map(str::trim)
|
||
.collect::<Vec<_>>()
|
||
.join("\n");
|
||
if data.is_empty() || data == "[DONE]" {
|
||
return None;
|
||
}
|
||
serde_json::from_str::<Value>(&data).ok()
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
async fn proxy_json(
|
||
context: &RequestContext,
|
||
method: reqwest::Method,
|
||
upstream: &str,
|
||
path: &str,
|
||
body: Option<Value>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
let url = upstream_url(upstream, path)?;
|
||
let client = reqwest::Client::builder()
|
||
.timeout(Duration::from_secs(1800))
|
||
.build()
|
||
.map_err(|error| {
|
||
WebError::internal(format!("Hermes client 构造失败: {error}")).with_context(context)
|
||
})?;
|
||
let mut request = client.request(method, url);
|
||
if let Some(api_key) = configured_api_key() {
|
||
request = request.bearer_auth(api_key);
|
||
}
|
||
if let Some(body) = body {
|
||
request = request.json(&body);
|
||
}
|
||
let response = request.send().await.map_err(|error| {
|
||
WebError::bad_gateway_code(
|
||
"hermes_client_upstream_unavailable",
|
||
format!("Hermes upstream 连接失败: {error}"),
|
||
)
|
||
.with_context(context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
let status = response.status();
|
||
let text = response.text().await.unwrap_or_default();
|
||
if !status.is_success() {
|
||
return Err(upstream_error(context, status, text));
|
||
}
|
||
let payload = serde_json::from_str::<Value>(&text).unwrap_or_else(|_| {
|
||
json!({
|
||
"ok": true,
|
||
"traceId": context.trace.trace_id,
|
||
"raw": text
|
||
})
|
||
});
|
||
Ok((
|
||
StatusCode::OK,
|
||
stamp_client_headers(),
|
||
Json(normalize_success_payload(context, payload)),
|
||
))
|
||
}
|
||
|
||
fn session_has_active_run(session_id: &str) -> bool {
|
||
let registry = HERMES_RUNTIME_REGISTRY
|
||
.lock()
|
||
.expect("hermes runtime registry");
|
||
registry
|
||
.get(session_id)
|
||
.map(|state| {
|
||
matches!(
|
||
state.status.as_str(),
|
||
"queued" | "running" | "tool_calling" | "aborting"
|
||
)
|
||
})
|
||
.unwrap_or(false)
|
||
}
|
||
|
||
fn queue_len_for_session(session_id: &str) -> usize {
|
||
HERMES_RUN_QUEUE
|
||
.lock()
|
||
.expect("hermes run queue")
|
||
.get(session_id)
|
||
.map(VecDeque::len)
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn queued_run_to_json(queued: &HermesQueuedRun, queue_length: usize) -> Value {
|
||
json!({
|
||
"ok": true,
|
||
"queued": true,
|
||
"queueId": queued.queue_id,
|
||
"sessionId": queued.session_id,
|
||
"profile": queued.profile,
|
||
"documentId": queued.document_id,
|
||
"traceId": queued.trace_id,
|
||
"status": "queued",
|
||
"queueLength": queue_length,
|
||
"queuedAt": queued.queued_at,
|
||
"contextSummary": queued.context_summary
|
||
})
|
||
}
|
||
|
||
fn enqueue_run(
|
||
context: &RequestContext,
|
||
registration: &HermesRunRegistration,
|
||
payload: &Value,
|
||
) -> Result<Value, WebError> {
|
||
let input = extract_run_message(payload).ok_or_else(|| {
|
||
WebError::bad_request_code("hermes_client_bad_request", "缺少 message")
|
||
.with_context(context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
})?;
|
||
let queued = HermesQueuedRun {
|
||
queue_id: format!(
|
||
"queue_{}_{}",
|
||
sanitize_id_part(®istration.trace_id),
|
||
now_ms()
|
||
),
|
||
session_id: registration.session_id.clone(),
|
||
profile: registration.profile.clone(),
|
||
document_id: registration.document_id.clone(),
|
||
trace_id: registration.trace_id.clone(),
|
||
actor_id: payload
|
||
.get("actorId")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or("anonymous")
|
||
.to_string(),
|
||
actor_type: payload
|
||
.get("actorType")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or("anonymous")
|
||
.to_string(),
|
||
input,
|
||
context_summary: queue_context_summary(payload),
|
||
queued_at: now_ms(),
|
||
};
|
||
let queue_length = {
|
||
let mut queue = HERMES_RUN_QUEUE.lock().expect("hermes run queue");
|
||
let entries = queue.entry(registration.session_id.clone()).or_default();
|
||
entries.push_back(queued.clone());
|
||
entries.len()
|
||
};
|
||
Ok(queued_run_to_json(&queued, queue_length))
|
||
}
|
||
|
||
async fn start_next_queued_run(context: RequestContext, session_id: String) {
|
||
if session_has_active_run(&session_id) {
|
||
return;
|
||
}
|
||
let Some(queued) = pop_next_queued_run(&session_id) else {
|
||
return;
|
||
};
|
||
let Some(upstream) = configured_upstream() else {
|
||
warn!(session_id = %session_id, queue_id = %queued.queue_id, "Hermes queue 无 upstream，无法自动启动下一条 run");
|
||
return;
|
||
};
|
||
let payload = queued_run_payload(&queued);
|
||
let upstream_body = match build_run_upstream_body(&context, payload) {
|
||
Ok(body) => body,
|
||
Err(error) => {
|
||
warn!(session_id = %session_id, queue_id = %queued.queue_id, error = ?error, "Hermes queue 构造 run body 失败");
|
||
return;
|
||
}
|
||
};
|
||
let registration = HermesRunRegistration {
|
||
session_id: queued.session_id.clone(),
|
||
profile: queued.profile.clone(),
|
||
document_id: queued.document_id.clone(),
|
||
trace_id: queued.trace_id.clone(),
|
||
};
|
||
match proxy_json(
|
||
&context,
|
||
reqwest::Method::POST,
|
||
&upstream,
|
||
"/v1/runs",
|
||
Some(upstream_body),
|
||
)
|
||
.await
|
||
{
|
||
Ok((_, _, Json(payload))) => {
|
||
let _ = register_runtime_from_create_run_response(®istration, &payload);
|
||
}
|
||
Err(error) => {
|
||
warn!(session_id = %session_id, queue_id = %queued.queue_id, error = ?error, "Hermes queue 自动启动下一条 run 失败");
|
||
}
|
||
}
|
||
}
|
||
|
||
fn queued_run_payload(queued: &HermesQueuedRun) -> Value {
|
||
json!({
|
||
"documentId": queued.document_id,
|
||
"sessionId": queued.session_id,
|
||
"profile": queued.profile,
|
||
"message": queued.input,
|
||
"traceId": queued.trace_id,
|
||
"actorId": queued.actor_id,
|
||
"actorType": queued.actor_type,
|
||
"contextScope": queued.context_summary.get("contextScope").cloned().unwrap_or(Value::Null)
|
||
})
|
||
}
|
||
|
||
fn remove_queued_run(session_id: &str, queue_id: &str) -> bool {
|
||
let mut queue = HERMES_RUN_QUEUE.lock().expect("hermes run queue");
|
||
let Some(entries) = queue.get_mut(session_id) else {
|
||
return false;
|
||
};
|
||
let before = entries.len();
|
||
entries.retain(|item| item.queue_id != queue_id);
|
||
let removed = entries.len() != before;
|
||
if entries.is_empty() {
|
||
queue.remove(session_id);
|
||
}
|
||
removed
|
||
}
|
||
|
||
fn pop_next_queued_run(session_id: &str) -> Option<HermesQueuedRun> {
|
||
let mut queue = HERMES_RUN_QUEUE.lock().expect("hermes run queue");
|
||
let entries = queue.get_mut(session_id)?;
|
||
let next = entries.pop_front();
|
||
if entries.is_empty() {
|
||
queue.remove(session_id);
|
||
}
|
||
next
|
||
}
|
||
|
||
fn extract_run_message(payload: &Value) -> Option<String> {
|
||
payload
|
||
.get("message")
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.map(ToOwned::to_owned)
|
||
.or_else(|| {
|
||
payload
|
||
.get("messages")
|
||
.and_then(Value::as_array)
|
||
.and_then(|messages| messages.last())
|
||
.and_then(|message| message.get("content"))
|
||
.and_then(Value::as_str)
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.map(ToOwned::to_owned)
|
||
})
|
||
}
|
||
|
||
fn queue_context_summary(payload: &Value) -> Value {
|
||
let page_context = payload.get("pageContext").unwrap_or(&Value::Null);
|
||
json!({
|
||
"contextScope": payload.get("contextScope").cloned().unwrap_or(Value::Null),
|
||
"selectedBlockId": payload.get("selectedBlockId").cloned().unwrap_or(Value::Null),
|
||
"hasSelectedText": payload.get("selectedText").and_then(Value::as_str).map(|value| !value.trim().is_empty()).unwrap_or(false),
|
||
"hasPageContext": !page_context.is_null(),
|
||
"pageContextKeys": page_context.as_object().map(|object| object.keys().take(12).cloned().collect::<Vec<_>>()).unwrap_or_default()
|
||
})
|
||
}
|
||
|
||
fn normalize_success_payload(context: &RequestContext, payload: Value) -> Value {
|
||
if payload.get("ok").is_some() {
|
||
payload
|
||
} else {
|
||
json!({
|
||
"ok": true,
|
||
"traceId": context.trace.trace_id,
|
||
"upstream": payload
|
||
})
|
||
}
|
||
}
|
||
|
||
fn upstream_error(context: &RequestContext, status: reqwest::StatusCode, text: String) -> WebError {
|
||
let (response_status, code) = match status {
|
||
reqwest::StatusCode::UNAUTHORIZED | reqwest::StatusCode::FORBIDDEN => (
|
||
StatusCode::BAD_GATEWAY,
|
||
"hermes_client_upstream_unauthorized",
|
||
),
|
||
reqwest::StatusCode::TOO_MANY_REQUESTS => (
|
||
StatusCode::TOO_MANY_REQUESTS,
|
||
"hermes_client_upstream_rate_limited",
|
||
),
|
||
status if status.is_server_error() => (
|
||
StatusCode::BAD_GATEWAY,
|
||
"hermes_client_upstream_unavailable",
|
||
),
|
||
_ => (StatusCode::BAD_GATEWAY, "hermes_client_upstream_error"),
|
||
};
|
||
let suggestions = hermes_settings_suggestions(Some(status.as_u16() as u64), Some(&text));
|
||
WebError::new(
|
||
response_status,
|
||
code,
|
||
format!(
|
||
"Hermes upstream 返回 HTTP {}: {}。建议：{}",
|
||
status.as_u16(),
|
||
text.chars().take(600).collect::<String>(),
|
||
suggestions.join("；")
|
||
),
|
||
)
|
||
.with_context(context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
.with_header("x-hermes-client-suggestion", suggestions.join(" | "))
|
||
}
|
||
|
||
fn hermes_unconfigured(
|
||
context: &RequestContext,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
Err(hermes_unconfigured_error(context))
|
||
}
|
||
|
||
fn hermes_unconfigured_error(context: &RequestContext) -> WebError {
|
||
WebError::service_unavailable_code(
|
||
"hermes_client_unconfigured",
|
||
"Hermes client proxy 未配置 MNOTE_WEB_HERMES_UPSTREAM_URL",
|
||
)
|
||
.with_context(context)
|
||
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web")
|
||
.with_header(HEADER_HERMES_CLIENT_OWNER, "mnote-web-hermes-client")
|
||
}
|
||
|
||
fn upstream_url(upstream: &str, path: &str) -> Result<String, WebError> {
|
||
let url = format!(
|
||
"{}/{}",
|
||
upstream.trim_end_matches('/'),
|
||
path.trim_start_matches('/')
|
||
);
|
||
reqwest::Url::parse(&url)
|
||
.map(|url| url.to_string())
|
||
.map_err(|error| WebError::internal(format!("Hermes upstream URL 无效: {error}")))
|
||
}
|
||
|
||
fn stable_session_id(document_id: &str, trace_id: &str) -> String {
|
||
format!(
|
||
"mnote_{}_{}",
|
||
sanitize_id_part(document_id),
|
||
sanitize_id_part(trace_id)
|
||
)
|
||
}
|
||
|
||
fn sanitize_id_part(value: &str) -> String {
|
||
let sanitized = value
|
||
.chars()
|
||
.map(|ch| {
|
||
if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' {
|
||
ch
|
||
} else {
|
||
'_'
|
||
}
|
||
})
|
||
.collect::<String>();
|
||
if sanitized.is_empty() {
|
||
"current".into()
|
||
} else {
|
||
sanitized
|
||
}
|
||
}
|
||
|
||
fn url_escape(value: &str) -> String {
|
||
value
|
||
.bytes()
|
||
.flat_map(|byte| match byte {
|
||
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
|
||
vec![byte as char]
|
||
}
|
||
_ => format!("%{byte:02X}").chars().collect(),
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn stamp_client_headers() -> HeaderMap {
|
||
let mut headers = HeaderMap::new();
|
||
stamp_client_headers_into(&mut headers);
|
||
headers
|
||
}
|
||
|
||
fn stamp_client_headers_into(headers: &mut HeaderMap) {
|
||
if let Ok(name) = HeaderName::from_lowercase(HEADER_MNOTE_WEB_OWNER.as_bytes()) {
|
||
headers.insert(name, HeaderValue::from_static("mnote-web"));
|
||
}
|
||
if let Ok(name) = HeaderName::from_lowercase(HEADER_HERMES_CLIENT_OWNER.as_bytes()) {
|
||
headers.insert(name, HeaderValue::from_static("mnote-web-hermes-client"));
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::app::{build_app, AppConfig, AppState};
|
||
use axum::body::{to_bytes, Body};
|
||
use axum::http::Request;
|
||
use axum::routing::{get, post};
|
||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||
use std::sync::{Arc, Mutex, OnceLock};
|
||
use tower::util::ServiceExt;
|
||
|
||
fn env_lock() -> &'static Mutex<()> {
|
||
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
|
||
LOCK.get_or_init(|| Mutex::new(()))
|
||
}
|
||
|
||
fn runtime_lock() -> &'static Mutex<()> {
|
||
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
|
||
LOCK.get_or_init(|| Mutex::new(()))
|
||
}
|
||
|
||
fn clear_runtime_registry() {
|
||
HERMES_RUNTIME_REGISTRY
|
||
.lock()
|
||
.expect("hermes runtime registry")
|
||
.clear();
|
||
}
|
||
|
||
fn clear_run_queue() {
|
||
HERMES_RUN_QUEUE.lock().expect("hermes run queue").clear();
|
||
}
|
||
|
||
fn app() -> axum::Router {
|
||
build_app(AppState::new(AppConfig {
|
||
service_name: "mnote-web".into(),
|
||
service_version: "0.1.0".into(),
|
||
bind_addr: "127.0.0.1:0".into(),
|
||
public_bind_addr: "127.0.0.1:3000".into(),
|
||
legacy_next_base_url: Some("http://127.0.0.1:3100".into()),
|
||
enable_legacy_next_compat: true,
|
||
enable_debug_shell_routes: false,
|
||
hermes_base_path: "/api/hermes".into(),
|
||
compat_next_base_path: "/api/compat/next".into(),
|
||
convex_url: None,
|
||
convex_admin_key: None,
|
||
allow_dev_fixtures: true,
|
||
query_fixtures_json: None,
|
||
mutation_fixtures_json: None,
|
||
dev_user_id: "dev-user".into(),
|
||
dev_user_name: "开发用户".into(),
|
||
dev_user_email: "dev@mnote.local".into(),
|
||
}))
|
||
}
|
||
|
||
fn test_state() -> AppState {
|
||
AppState::new(AppConfig {
|
||
service_name: "mnote-web".into(),
|
||
service_version: "0.1.0".into(),
|
||
bind_addr: "127.0.0.1:0".into(),
|
||
public_bind_addr: "127.0.0.1:3000".into(),
|
||
legacy_next_base_url: Some("http://127.0.0.1:3100".into()),
|
||
enable_legacy_next_compat: true,
|
||
enable_debug_shell_routes: false,
|
||
hermes_base_path: "/api/hermes".into(),
|
||
compat_next_base_path: "/api/compat/next".into(),
|
||
convex_url: None,
|
||
convex_admin_key: None,
|
||
allow_dev_fixtures: true,
|
||
query_fixtures_json: None,
|
||
mutation_fixtures_json: None,
|
||
dev_user_id: "dev-user".into(),
|
||
dev_user_name: "开发用户".into(),
|
||
dev_user_email: "dev@mnote.local".into(),
|
||
})
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_gateway_health_reports_unconfigured_profile_settings() {
|
||
let _env_guard = env_lock().lock().expect("env lock");
|
||
std::env::remove_var("MNOTE_WEB_HERMES_UPSTREAM_URL");
|
||
std::env::remove_var("MNOTE_HERMES_UPSTREAM_URL");
|
||
std::env::remove_var("MNOTE_HERMES_API_BASE_URL");
|
||
let hermes_home = std::env::temp_dir().join(format!(
|
||
"mnote-web-hermes-health-unconfigured-{}",
|
||
std::process::id()
|
||
));
|
||
let _ = fs::remove_dir_all(&hermes_home);
|
||
fs::create_dir_all(&hermes_home).expect("hermes home");
|
||
std::env::set_var("HERMES_HOME", &hermes_home);
|
||
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/hermes/client/gateway/health?profile=default")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::empty())
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("json");
|
||
assert_eq!(payload["ok"], false);
|
||
assert_eq!(payload["gateway"]["status"], "unconfigured");
|
||
assert_eq!(payload["profile"]["modelConfigured"], false);
|
||
let suggestions = payload["suggestions"].to_string();
|
||
assert!(suggestions.contains("MNOTE_WEB_HERMES_UPSTREAM_URL"));
|
||
assert!(suggestions.contains("model.default"));
|
||
|
||
std::env::remove_var("HERMES_HOME");
|
||
let _ = fs::remove_dir_all(&hermes_home);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_gateway_health_reports_profile_model_and_api_key_gaps() {
|
||
let _env_guard = env_lock().lock().expect("env lock");
|
||
let hermes_home = std::env::temp_dir().join(format!(
|
||
"mnote-web-hermes-health-profile-{}",
|
||
std::process::id()
|
||
));
|
||
let _ = fs::remove_dir_all(&hermes_home);
|
||
let profile_dir = hermes_home.join("profiles").join("chemist");
|
||
fs::create_dir_all(&profile_dir).expect("profile dir");
|
||
fs::write(
|
||
profile_dir.join("config.yaml"),
|
||
"model:\n provider: openai\nproviders:\n openai:\n base_url: https://api.openai.com/v1\n",
|
||
)
|
||
.expect("profile config");
|
||
std::env::set_var("HERMES_HOME", &hermes_home);
|
||
|
||
let mock = axum::Router::new().route(
|
||
"/v1/models",
|
||
get(|| async { (StatusCode::BAD_REQUEST, "missing model.default and API key") }),
|
||
);
|
||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
|
||
.await
|
||
.expect("listener");
|
||
let upstream = format!("http://{}", listener.local_addr().expect("addr"));
|
||
tokio::spawn(async move {
|
||
axum::serve(listener, mock).await.expect("mock upstream");
|
||
});
|
||
std::env::set_var("MNOTE_WEB_HERMES_UPSTREAM_URL", &upstream);
|
||
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/hermes/client/gateway/health?profile=chemist")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::empty())
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("json");
|
||
assert_eq!(payload["ok"], false);
|
||
assert_eq!(payload["gateway"]["status"], "upstream_error");
|
||
assert_eq!(payload["profile"]["name"], "chemist");
|
||
assert_eq!(payload["profile"]["modelConfigured"], false);
|
||
assert_eq!(payload["profile"]["apiKeyConfigured"], false);
|
||
let suggestions = payload["suggestions"].to_string();
|
||
assert!(suggestions.contains("model.default"));
|
||
assert!(suggestions.contains("API key"));
|
||
|
||
std::env::remove_var("HERMES_HOME");
|
||
std::env::remove_var("MNOTE_WEB_HERMES_UPSTREAM_URL");
|
||
let _ = fs::remove_dir_all(&hermes_home);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_upstream_error_message_points_to_hermes_settings() {
|
||
let _env_guard = env_lock().lock().expect("env lock");
|
||
let _runtime_guard = runtime_lock().lock().expect("runtime lock");
|
||
clear_runtime_registry();
|
||
clear_run_queue();
|
||
let mock = axum::Router::new().route(
|
||
"/v1/runs",
|
||
post(|| async { (StatusCode::BAD_REQUEST, "missing model.default and API key") }),
|
||
);
|
||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
|
||
.await
|
||
.expect("listener");
|
||
let upstream = format!("http://{}", listener.local_addr().expect("addr"));
|
||
tokio::spawn(async move {
|
||
axum::serve(listener, mock).await.expect("mock upstream");
|
||
});
|
||
std::env::set_var("MNOTE_WEB_HERMES_UPSTREAM_URL", &upstream);
|
||
std::env::remove_var("MNOTE_HERMES_UPSTREAM_URL");
|
||
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/hermes/client/runs")
|
||
.header("content-type", "application/json")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::from(
|
||
json!({
|
||
"documentId": "doc_error",
|
||
"sessionId": "mnote_doc_error_trace_1",
|
||
"profile": "chemist",
|
||
"message": "测试错误提示",
|
||
"traceId": "trace_error_1"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("json");
|
||
assert_eq!(payload["code"], "hermes_client_upstream_error");
|
||
let message = payload["message"].as_str().unwrap_or_default();
|
||
assert!(message.contains("model.default"));
|
||
assert!(message.contains("API key"));
|
||
assert!(message.contains("Hermes 设置"));
|
||
|
||
std::env::remove_var("MNOTE_WEB_HERMES_UPSTREAM_URL");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_unauthenticated_requests_return_401() {
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/hermes/client/sessions")
|
||
.header("content-type", "application/json")
|
||
.body(Body::from(json!({"documentId":"doc_1"}).to_string()))
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
||
assert_eq!(
|
||
response
|
||
.headers()
|
||
.get("x-error-code")
|
||
.and_then(|value| value.to_str().ok()),
|
||
Some("hermes_client_unauthorized")
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_unconfigured_run_returns_stable_error() {
|
||
let _guard = env_lock().lock().expect("env lock");
|
||
std::env::remove_var("MNOTE_WEB_HERMES_UPSTREAM_URL");
|
||
std::env::remove_var("MNOTE_HERMES_UPSTREAM_URL");
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/hermes/client/runs")
|
||
.header("content-type", "application/json")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::from(
|
||
json!({
|
||
"workspaceId": "ws_1",
|
||
"documentId": "doc_1",
|
||
"sessionId": "sess_1",
|
||
"message": "ping",
|
||
"traceId": "trace_1"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
|
||
assert_eq!(
|
||
response
|
||
.headers()
|
||
.get("x-error-code")
|
||
.and_then(|value| value.to_str().ok()),
|
||
Some("hermes_client_unconfigured")
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_session_create_does_not_require_upstream_or_store_chat() {
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/hermes/client/sessions")
|
||
.header("content-type", "application/json")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::from(
|
||
json!({
|
||
"workspaceId": "ws_1",
|
||
"documentId": "doc_1",
|
||
"traceId": "trace_1",
|
||
"title": "当前页问答"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("json");
|
||
assert_eq!(payload["ok"], true);
|
||
assert_eq!(payload["sessionId"], "mnote_doc_1_trace_1");
|
||
assert_eq!(payload["persistence"], "hermes_on_first_run");
|
||
assert!(payload.get("messages").is_none());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_session_create_carries_agent_profile_without_storing_chat() {
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/hermes/client/sessions")
|
||
.header("content-type", "application/json")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::from(
|
||
json!({
|
||
"workspaceId": "ws_1",
|
||
"documentId": "doc_1",
|
||
"traceId": "trace_1",
|
||
"title": "当前页问答",
|
||
"profile": "chemist"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("json");
|
||
assert_eq!(payload["sessionId"], "mnote_doc_1_trace_1");
|
||
assert_eq!(payload["profile"], "chemist");
|
||
assert!(payload.get("messages").is_none());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_resume_returns_runtime_state_without_chat_store() {
|
||
let _guard = runtime_lock().lock().expect("runtime lock");
|
||
clear_runtime_registry();
|
||
clear_run_queue();
|
||
let registration = HermesRunRegistration {
|
||
session_id: "mnote_doc_1_trace_1".into(),
|
||
profile: "chemist".into(),
|
||
document_id: "doc_1".into(),
|
||
trace_id: "trace_1".into(),
|
||
};
|
||
let runtime = register_runtime_from_create_run_response(
|
||
®istration,
|
||
&json!({
|
||
"ok": true,
|
||
"upstream": {"run_id": "run_1"}
|
||
}),
|
||
)
|
||
.expect("runtime");
|
||
assert_eq!(runtime["sessionId"], "mnote_doc_1_trace_1");
|
||
assert_eq!(runtime["runId"], "run_1");
|
||
assert!(runtime.get("messages").is_none());
|
||
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/hermes/client/sessions/mnote_doc_1_trace_1/resume")
|
||
.header("content-type", "application/json")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::empty())
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("json");
|
||
assert_eq!(payload["ok"], true);
|
||
assert_eq!(
|
||
payload["session"]["messages"].as_array().map(Vec::len),
|
||
Some(0)
|
||
);
|
||
assert_eq!(payload["runtime"]["sessionId"], "mnote_doc_1_trace_1");
|
||
assert_eq!(payload["runtime"]["runId"], "run_1");
|
||
assert_eq!(payload["runtime"]["status"], "running");
|
||
}
|
||
|
||
#[test]
|
||
fn hermes_client_active_session_queues_second_run_without_chat_truth() {
|
||
let _guard = runtime_lock().lock().expect("runtime lock");
|
||
clear_runtime_registry();
|
||
clear_run_queue();
|
||
let context = RequestContext::from_http_parts(
|
||
&axum::http::Method::POST,
|
||
&"/api/hermes/client/runs".parse().expect("uri"),
|
||
&HeaderMap::new(),
|
||
);
|
||
let registration = HermesRunRegistration {
|
||
session_id: "mnote_doc_queue_trace_1".into(),
|
||
profile: "chemist".into(),
|
||
document_id: "doc_queue".into(),
|
||
trace_id: "trace_queued_1".into(),
|
||
};
|
||
register_runtime_from_create_run_response(
|
||
®istration,
|
||
&json!({
|
||
"ok": true,
|
||
"upstream": {"run_id": "run_active_1"}
|
||
}),
|
||
)
|
||
.expect("runtime");
|
||
assert!(session_has_active_run("mnote_doc_queue_trace_1"));
|
||
|
||
let queued = enqueue_run(
|
||
&context,
|
||
®istration,
|
||
&json!({
|
||
"workspaceId": "ws_1",
|
||
"documentId": "doc_queue",
|
||
"sessionId": "mnote_doc_queue_trace_1",
|
||
"profile": "chemist",
|
||
"message": "第二条问题",
|
||
"traceId": "trace_queued_1",
|
||
"selectedText": "选区",
|
||
"pageContext": {
|
||
"title": "页面标题",
|
||
"body": "正文不应进入 queue 响应",
|
||
"blocks": [{"id": "block_1"}]
|
||
},
|
||
"messages": [
|
||
{"role": "assistant", "content": "历史消息不应保存为 mnote 真相"}
|
||
]
|
||
}),
|
||
)
|
||
.expect("queued");
|
||
assert_eq!(queued["queued"], true);
|
||
assert_eq!(queued["queueLength"], 1);
|
||
assert_eq!(queued["sessionId"], "mnote_doc_queue_trace_1");
|
||
assert!(queued.get("messages").is_none());
|
||
assert!(queued.get("pageContext").is_none());
|
||
assert_eq!(queued["contextSummary"]["hasPageContext"], true);
|
||
assert_eq!(queued["contextSummary"]["hasSelectedText"], true);
|
||
|
||
let popped = pop_next_queued_run("mnote_doc_queue_trace_1").expect("queued run");
|
||
assert_eq!(popped.input, "第二条问题");
|
||
assert_eq!(popped.profile, "chemist");
|
||
assert!(popped.context_summary.get("pageContext").is_none());
|
||
assert_eq!(queue_len_for_session("mnote_doc_queue_trace_1"), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn hermes_client_cancel_queued_run_removes_pending_item() {
|
||
let _guard = runtime_lock().lock().expect("runtime lock");
|
||
clear_runtime_registry();
|
||
clear_run_queue();
|
||
let context = RequestContext::from_http_parts(
|
||
&axum::http::Method::POST,
|
||
&"/api/hermes/client/runs".parse().expect("uri"),
|
||
&HeaderMap::new(),
|
||
);
|
||
let registration = HermesRunRegistration {
|
||
session_id: "mnote_doc_cancel_trace_1".into(),
|
||
profile: "default".into(),
|
||
document_id: "doc_cancel".into(),
|
||
trace_id: "trace_cancel_1".into(),
|
||
};
|
||
let queued = enqueue_run(
|
||
&context,
|
||
®istration,
|
||
&json!({
|
||
"documentId": "doc_cancel",
|
||
"sessionId": "mnote_doc_cancel_trace_1",
|
||
"message": "等待取消",
|
||
"traceId": "trace_cancel_1"
|
||
}),
|
||
)
|
||
.expect("queued");
|
||
let queue_id = queued["queueId"].as_str().expect("queue id");
|
||
assert_eq!(queue_len_for_session("mnote_doc_cancel_trace_1"), 1);
|
||
assert!(remove_queued_run("mnote_doc_cancel_trace_1", queue_id));
|
||
assert_eq!(queue_len_for_session("mnote_doc_cancel_trace_1"), 0);
|
||
assert!(pop_next_queued_run("mnote_doc_cancel_trace_1").is_none());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_terminal_run_can_start_next_queued_run() {
|
||
let _env_guard = env_lock().lock().expect("env lock");
|
||
let _runtime_guard = runtime_lock().lock().expect("runtime lock");
|
||
clear_runtime_registry();
|
||
clear_run_queue();
|
||
|
||
let hits = Arc::new(AtomicUsize::new(0));
|
||
let hits_for_route = Arc::clone(&hits);
|
||
let mock = axum::Router::new().route(
|
||
"/v1/runs",
|
||
post(move |Json(_body): Json<Value>| {
|
||
let hits = Arc::clone(&hits_for_route);
|
||
async move {
|
||
hits.fetch_add(1, Ordering::SeqCst);
|
||
Json(json!({
|
||
"run_id": "run_queued_next",
|
||
"trace_id": "trace_queued_next"
|
||
}))
|
||
}
|
||
}),
|
||
);
|
||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
|
||
.await
|
||
.expect("listener");
|
||
let upstream = format!("http://{}", listener.local_addr().expect("addr"));
|
||
tokio::spawn(async move {
|
||
axum::serve(listener, mock).await.expect("mock upstream");
|
||
});
|
||
std::env::set_var("MNOTE_WEB_HERMES_UPSTREAM_URL", &upstream);
|
||
std::env::remove_var("MNOTE_HERMES_UPSTREAM_URL");
|
||
|
||
let context = RequestContext::from_http_parts(
|
||
&axum::http::Method::POST,
|
||
&"/api/hermes/client/runs".parse().expect("uri"),
|
||
&HeaderMap::new(),
|
||
);
|
||
let registration = HermesRunRegistration {
|
||
session_id: "mnote_doc_auto_trace_1".into(),
|
||
profile: "chemist".into(),
|
||
document_id: "doc_auto".into(),
|
||
trace_id: "trace_auto_1".into(),
|
||
};
|
||
register_runtime_from_create_run_response(
|
||
®istration,
|
||
&json!({
|
||
"ok": true,
|
||
"upstream": {"run_id": "run_active_auto"}
|
||
}),
|
||
)
|
||
.expect("runtime");
|
||
enqueue_run(
|
||
&context,
|
||
®istration,
|
||
&json!({
|
||
"workspaceId": "ws_1",
|
||
"documentId": "doc_auto",
|
||
"sessionId": "mnote_doc_auto_trace_1",
|
||
"profile": "chemist",
|
||
"message": "自动出队问题",
|
||
"traceId": "trace_auto_1",
|
||
"pageContext": {"title": "自动出队"}
|
||
}),
|
||
)
|
||
.expect("queued");
|
||
|
||
let (_, terminal_sessions) = normalize_sse_chunk(
|
||
"run_active_auto",
|
||
&format!(
|
||
"data: {}\n\n",
|
||
json!({
|
||
"event": "run.completed",
|
||
"run_id": "run_active_auto",
|
||
"session_id": "mnote_doc_auto_trace_1"
|
||
})
|
||
),
|
||
);
|
||
assert_eq!(
|
||
terminal_sessions,
|
||
vec!["mnote_doc_auto_trace_1".to_string()]
|
||
);
|
||
|
||
start_next_queued_run(context, "mnote_doc_auto_trace_1".into()).await;
|
||
assert_eq!(hits.load(Ordering::SeqCst), 1);
|
||
assert_eq!(queue_len_for_session("mnote_doc_auto_trace_1"), 0);
|
||
let runtime = runtime_state_for_session("mnote_doc_auto_trace_1");
|
||
assert_eq!(runtime["runId"], "run_queued_next");
|
||
assert_eq!(runtime["status"], "running");
|
||
|
||
std::env::remove_var("MNOTE_WEB_HERMES_UPSTREAM_URL");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_abort_returns_events_and_continues_queue() {
|
||
let _env_guard = env_lock().lock().expect("env lock");
|
||
let _runtime_guard = runtime_lock().lock().expect("runtime lock");
|
||
clear_runtime_registry();
|
||
clear_run_queue();
|
||
|
||
let stop_hits = Arc::new(AtomicUsize::new(0));
|
||
let run_hits = Arc::new(AtomicUsize::new(0));
|
||
let stop_hits_for_route = Arc::clone(&stop_hits);
|
||
let run_hits_for_route = Arc::clone(&run_hits);
|
||
let mock = axum::Router::new()
|
||
.route(
|
||
"/v1/runs/{run_id}/stop",
|
||
post(move || {
|
||
let stop_hits = Arc::clone(&stop_hits_for_route);
|
||
async move {
|
||
stop_hits.fetch_add(1, Ordering::SeqCst);
|
||
Json(json!({"ok": true, "status": "aborted"}))
|
||
}
|
||
}),
|
||
)
|
||
.route(
|
||
"/v1/runs",
|
||
post(move |Json(_body): Json<Value>| {
|
||
let run_hits = Arc::clone(&run_hits_for_route);
|
||
async move {
|
||
run_hits.fetch_add(1, Ordering::SeqCst);
|
||
Json(json!({
|
||
"run_id": "run_after_abort",
|
||
"trace_id": "trace_after_abort"
|
||
}))
|
||
}
|
||
}),
|
||
);
|
||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
|
||
.await
|
||
.expect("listener");
|
||
let upstream = format!("http://{}", listener.local_addr().expect("addr"));
|
||
tokio::spawn(async move {
|
||
axum::serve(listener, mock).await.expect("mock upstream");
|
||
});
|
||
std::env::set_var("MNOTE_WEB_HERMES_UPSTREAM_URL", &upstream);
|
||
std::env::remove_var("MNOTE_HERMES_UPSTREAM_URL");
|
||
|
||
let context = RequestContext::from_http_parts(
|
||
&axum::http::Method::POST,
|
||
&"/api/hermes/client/runs/run_abort_1/abort"
|
||
.parse()
|
||
.expect("uri"),
|
||
&HeaderMap::new(),
|
||
);
|
||
let registration = HermesRunRegistration {
|
||
session_id: "mnote_doc_abort_trace_1".into(),
|
||
profile: "default".into(),
|
||
document_id: "doc_abort".into(),
|
||
trace_id: "trace_abort_1".into(),
|
||
};
|
||
register_runtime_from_create_run_response(
|
||
®istration,
|
||
&json!({
|
||
"ok": true,
|
||
"upstream": {"run_id": "run_abort_1"}
|
||
}),
|
||
)
|
||
.expect("runtime");
|
||
enqueue_run(
|
||
&context,
|
||
®istration,
|
||
&json!({
|
||
"documentId": "doc_abort",
|
||
"sessionId": "mnote_doc_abort_trace_1",
|
||
"message": "abort 后继续",
|
||
"traceId": "trace_abort_1"
|
||
}),
|
||
)
|
||
.expect("queued");
|
||
|
||
let response = app()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/hermes/client/runs/run_abort_1/abort")
|
||
.header("content-type", "application/json")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::from(json!({"reason":"test_abort"}).to_string()))
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("json");
|
||
assert_eq!(payload["events"][0]["event"], "abort.started");
|
||
assert_eq!(payload["events"][1]["event"], "abort.completed");
|
||
assert_eq!(stop_hits.load(Ordering::SeqCst), 1);
|
||
assert_eq!(run_hits.load(Ordering::SeqCst), 1);
|
||
assert_eq!(queue_len_for_session("mnote_doc_abort_trace_1"), 0);
|
||
let runtime = runtime_state_for_session("mnote_doc_abort_trace_1");
|
||
assert_eq!(runtime["runId"], "run_after_abort");
|
||
assert_eq!(runtime["status"], "running");
|
||
|
||
std::env::remove_var("MNOTE_WEB_HERMES_UPSTREAM_URL");
|
||
}
|
||
|
||
#[test]
|
||
fn hermes_client_runtime_registry_tracks_tool_event_summary_only() {
|
||
let _guard = runtime_lock().lock().expect("runtime lock");
|
||
clear_runtime_registry();
|
||
clear_run_queue();
|
||
let registration = HermesRunRegistration {
|
||
session_id: "mnote_doc_2_trace_2".into(),
|
||
profile: "default".into(),
|
||
document_id: "doc_2".into(),
|
||
trace_id: "trace_2".into(),
|
||
};
|
||
register_runtime_from_create_run_response(
|
||
®istration,
|
||
&json!({
|
||
"ok": true,
|
||
"runId": "run_2"
|
||
}),
|
||
)
|
||
.expect("runtime");
|
||
let _ = normalize_sse_chunk(
|
||
"run_2",
|
||
&format!(
|
||
"data: {}\n\n",
|
||
json!({
|
||
"event": "tool.started",
|
||
"run_id": "run_2",
|
||
"session_id": "mnote_doc_2_trace_2",
|
||
"name": "mnote.page.get",
|
||
"toolCallId": "call_1",
|
||
"arguments": {"includeBody": false}
|
||
})
|
||
),
|
||
);
|
||
let runtime = runtime_state_for_session("mnote_doc_2_trace_2");
|
||
assert_eq!(runtime["status"], "tool_calling");
|
||
assert_eq!(runtime["lastToolName"], "mnote.page.get");
|
||
assert_eq!(runtime["lastToolCallId"], "call_1");
|
||
assert!(runtime.get("arguments").is_none());
|
||
assert!(runtime.get("messages").is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn hermes_client_normalizes_upstream_sse_events_to_runtime_contract() {
|
||
let _guard = runtime_lock().lock().expect("runtime lock");
|
||
clear_runtime_registry();
|
||
clear_run_queue();
|
||
let registration = HermesRunRegistration {
|
||
session_id: "mnote_doc_norm_trace_1".into(),
|
||
profile: "default".into(),
|
||
document_id: "doc_norm".into(),
|
||
trace_id: "trace_norm_1".into(),
|
||
};
|
||
register_runtime_from_create_run_response(
|
||
®istration,
|
||
&json!({
|
||
"ok": true,
|
||
"runId": "run_norm_1"
|
||
}),
|
||
)
|
||
.expect("runtime");
|
||
|
||
let (normalized, terminal_sessions) = normalize_sse_chunk(
|
||
"run_norm_1",
|
||
&format!(
|
||
"data: {}\n\ndata: {}\n\n",
|
||
json!({
|
||
"event": "assistant_message",
|
||
"run_id": "run_norm_1",
|
||
"session_id": "mnote_doc_norm_trace_1",
|
||
"text": "hello"
|
||
}),
|
||
json!({
|
||
"event": "tool.failed",
|
||
"run_id": "run_norm_1",
|
||
"session_id": "mnote_doc_norm_trace_1",
|
||
"toolCallId": "call_failed_1",
|
||
"name": "mnote.page.save",
|
||
"code": "permission_denied",
|
||
"error": "写入被拒绝"
|
||
})
|
||
),
|
||
);
|
||
assert!(normalized.contains("event: message.delta"));
|
||
assert!(normalized.contains("\"schemaVersion\":\"mnote.hermes_runtime_event.v1\""));
|
||
assert!(normalized.contains("\"event\":\"tool.failed\""));
|
||
assert!(normalized.contains("\"toolCallId\":\"call_failed_1\""));
|
||
assert!(normalized.contains("\"code\":\"permission_denied\""));
|
||
assert!(terminal_sessions.is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn hermes_client_run_body_carries_minimal_page_context_into_run_input() {
|
||
let context = RequestContext::from_http_parts(
|
||
&axum::http::Method::POST,
|
||
&"/api/hermes/client/runs".parse().expect("uri"),
|
||
&HeaderMap::new(),
|
||
);
|
||
let body = build_run_upstream_body(
|
||
&context,
|
||
json!({
|
||
"workspaceId": "ws_1",
|
||
"documentId": "doc_1",
|
||
"sessionId": "sess_1",
|
||
"message": "概括当前页面",
|
||
"pageContext": {
|
||
"contextScope": "page",
|
||
"node": {"documentId": "doc_1", "title": "页面标题"},
|
||
"documentBlocks": [{"type": "paragraph", "text": "不应进入 Hermes instructions"}],
|
||
"subtree": {"children": [{"title": "不应进入 Hermes instructions"}]},
|
||
"outline": [{"title": "不应进入 Hermes instructions"}],
|
||
"contentAccess": "mnote.page.get"
|
||
},
|
||
"selectedBlockId": "block_1",
|
||
"selectedText": "选中文本",
|
||
"traceId": "trace_1"
|
||
}),
|
||
)
|
||
.expect("body");
|
||
assert_eq!(body["input"], "概括当前页面");
|
||
assert_eq!(body["session_id"], "sess_1");
|
||
let instructions = body["instructions"].as_str().expect("instructions");
|
||
assert!(instructions.contains("\"workspaceId\":\"ws_1\""));
|
||
assert!(instructions.contains("\"documentId\":\"doc_1\""));
|
||
assert!(instructions.contains("\"title\":\"页面标题\""));
|
||
assert!(instructions.contains("\"selectedBlockId\":\"block_1\""));
|
||
assert!(instructions.contains("\"contentAccess\":\"mnote.page.get\""));
|
||
assert!(!instructions.contains("不应进入 Hermes instructions"));
|
||
assert!(!instructions.contains("\"documentBlocks\""));
|
||
assert!(!instructions.contains("\"subtree\""));
|
||
assert!(!instructions.contains("\"outline\""));
|
||
}
|
||
|
||
#[test]
|
||
fn hermes_client_run_actor_falls_back_to_dev_user_for_cookie_auth() {
|
||
let state = test_state();
|
||
let mut headers = HeaderMap::new();
|
||
headers.insert("cookie", "mnote_web_convex_token=token_1".parse().unwrap());
|
||
let context = RequestContext::from_http_parts(
|
||
&axum::http::Method::POST,
|
||
&"/api/hermes/client/runs".parse().expect("uri"),
|
||
&headers,
|
||
);
|
||
let (actor_id, actor_type) = effective_run_actor(&state, &context);
|
||
assert_eq!(actor_id, "dev-user");
|
||
assert_eq!(actor_type, "devFallback");
|
||
let mut payload = json!({"message": "读取当前页面"});
|
||
stamp_run_actor(&mut payload, &actor_id, &actor_type);
|
||
let body = build_run_upstream_body(&context, payload).expect("body");
|
||
let instructions = body["instructions"].as_str().expect("instructions");
|
||
assert!(instructions.contains("\"actorId\":\"dev-user\""));
|
||
assert!(instructions.contains("\"actorType\":\"devFallback\""));
|
||
assert!(!instructions.contains("\"actorId\":\"anonymous\""));
|
||
}
|
||
|
||
#[test]
|
||
fn hermes_client_run_body_carries_agent_profile() {
|
||
let context = RequestContext::from_http_parts(
|
||
&axum::http::Method::POST,
|
||
&"/api/hermes/client/runs".parse().expect("uri"),
|
||
&HeaderMap::new(),
|
||
);
|
||
let body = build_run_upstream_body(
|
||
&context,
|
||
json!({
|
||
"workspaceId": "ws_1",
|
||
"documentId": "doc_1",
|
||
"sessionId": "sess_1",
|
||
"message": "用当前 agent 回答",
|
||
"profile": "chemist",
|
||
"traceId": "trace_1"
|
||
}),
|
||
)
|
||
.expect("body");
|
||
assert_eq!(body["profile"], "chemist");
|
||
let instructions = body["instructions"].as_str().expect("instructions");
|
||
assert!(instructions.contains("\"profile\":\"chemist\""));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hermes_client_profile_skill_and_memory_routes_use_local_bff_without_upstream() {
|
||
let _guard = env_lock().lock().expect("env lock");
|
||
std::env::remove_var("MNOTE_WEB_HERMES_UPSTREAM_URL");
|
||
std::env::remove_var("MNOTE_HERMES_UPSTREAM_URL");
|
||
let hermes_home = std::env::temp_dir().join(format!(
|
||
"mnote-web-hermes-client-test-{}",
|
||
std::process::id()
|
||
));
|
||
let _ = fs::remove_dir_all(&hermes_home);
|
||
for name in ["draft", "installed-demo", "builtin-demo"] {
|
||
fs::create_dir_all(hermes_home.join("skills").join("writing").join(name))
|
||
.expect("test skill dir");
|
||
fs::write(
|
||
hermes_home
|
||
.join("skills")
|
||
.join("writing")
|
||
.join(name)
|
||
.join("SKILL.md"),
|
||
format!("# {name}\n\n写作助手"),
|
||
)
|
||
.expect("test skill");
|
||
}
|
||
fs::create_dir_all(hermes_home.join("skills").join("copied-demo"))
|
||
.expect("test copied skill dir");
|
||
fs::write(
|
||
hermes_home
|
||
.join("skills")
|
||
.join("copied-demo")
|
||
.join("SKILL.md"),
|
||
"# copied-demo\n\n复制技能",
|
||
)
|
||
.expect("test copied skill");
|
||
fs::write(
|
||
hermes_home.join("skills").join(".bundled_manifest"),
|
||
"builtin-demo:abc123\n",
|
||
)
|
||
.expect("test bundled manifest");
|
||
fs::create_dir_all(hermes_home.join("skills").join(".hub")).expect("test hub dir");
|
||
fs::write(
|
||
hermes_home.join("skills").join(".hub").join("lock.json"),
|
||
json!({
|
||
"installed": {
|
||
"installed-demo": {
|
||
"source": "skills.sh",
|
||
"install_path": "writing/installed-demo"
|
||
}
|
||
}
|
||
})
|
||
.to_string(),
|
||
)
|
||
.expect("test hub lock");
|
||
fs::write(
|
||
hermes_home.join("skills").join(".usage.json"),
|
||
json!({
|
||
"draft": {
|
||
"created_by": "agent",
|
||
"created_at": "2026-05-14T00:00:00Z",
|
||
"patch_count": 2
|
||
}
|
||
})
|
||
.to_string(),
|
||
)
|
||
.expect("test usage");
|
||
std::env::set_var("HERMES_HOME", &hermes_home);
|
||
std::env::set_var("MNOTE_WEB_HERMES_BIN", "__missing_hermes_for_test__");
|
||
let cases = [
|
||
("GET", "/api/hermes/client/profiles", None),
|
||
("GET", "/api/hermes/client/profiles/chemist", None),
|
||
(
|
||
"GET",
|
||
"/api/hermes/client/profile-memory?profile=chemist",
|
||
None,
|
||
),
|
||
("GET", "/api/hermes/client/skills?profile=chemist", None),
|
||
(
|
||
"PUT",
|
||
"/api/hermes/client/profiles/active",
|
||
Some(json!({"name": "chemist"})),
|
||
),
|
||
(
|
||
"POST",
|
||
"/api/hermes/client/profile-memory",
|
||
Some(json!({"profile": "chemist", "section": "soul", "content": "test"})),
|
||
),
|
||
(
|
||
"PUT",
|
||
"/api/hermes/client/skills/toggle",
|
||
Some(json!({"name": "chem", "enabled": true})),
|
||
),
|
||
];
|
||
for (method, uri, body) in cases {
|
||
let request = Request::builder()
|
||
.method(method)
|
||
.uri(uri)
|
||
.header("content-type", "application/json")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::from(body.unwrap_or_else(|| json!({})).to_string()))
|
||
.expect("request");
|
||
let response = app().oneshot(request).await.expect("response");
|
||
assert_eq!(response.status(), StatusCode::OK, "{uri}");
|
||
}
|
||
assert_eq!(
|
||
fs::read_to_string(hermes_home.join("active_profile"))
|
||
.expect("active profile")
|
||
.trim(),
|
||
"chemist"
|
||
);
|
||
assert_eq!(
|
||
fs::read_to_string(hermes_home.join("profiles").join("chemist").join("SOUL.md"))
|
||
.expect("soul"),
|
||
"test"
|
||
);
|
||
let request = Request::builder()
|
||
.method("GET")
|
||
.uri("/api/hermes/client/skills?profile=chemist")
|
||
.header("x-mnote-actor-id", "user_1")
|
||
.body(Body::empty())
|
||
.expect("request");
|
||
let response = app().oneshot(request).await.expect("response");
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("skills json");
|
||
let skills = payload["categories"]
|
||
.as_array()
|
||
.expect("categories")
|
||
.iter()
|
||
.flat_map(|category| category["skills"].as_array().into_iter().flatten())
|
||
.map(|skill| {
|
||
(
|
||
skill["name"].as_str().unwrap_or_default().to_string(),
|
||
skill.clone(),
|
||
)
|
||
})
|
||
.collect::<HashMap<_, _>>();
|
||
assert_eq!(skills["draft"]["origin"], "generated");
|
||
assert_eq!(skills["draft"]["createdBy"], "agent");
|
||
assert_eq!(skills["installed-demo"]["source"], "hub");
|
||
assert_eq!(skills["installed-demo"]["origin"], "installed");
|
||
assert_eq!(skills["builtin-demo"]["source"], "builtin");
|
||
assert_eq!(skills["copied-demo"]["origin"], "copied");
|
||
std::env::remove_var("HERMES_HOME");
|
||
std::env::remove_var("MNOTE_WEB_HERMES_BIN");
|
||
let _ = fs::remove_dir_all(&hermes_home);
|
||
}
|
||
}
|