AstrBot-Desktop/crates/mock-gateway/src/routes.rs

375 行
11 KiB
Rust

use std::{convert::Infallible, sync::Arc, time::Duration};
use axum::{
Json, Router,
extract::{Path, State},
http::{HeaderMap, StatusCode, header::AUTHORIZATION},
response::{
IntoResponse, Response, Sse,
sse::{Event, KeepAlive},
},
routing::{get, post},
};
use desktop_protocol::{
AuthLoginRequest, AuthLoginResponse, AuthRefreshRequest, EventAcknowledgement, FinishReason,
GatewayErrorResponse, GatewayEvent, GatewayEventBody, HealthResponse, LocalActionDecision,
LocalActionDecisionKind, LocalActionProgress, MessageCompletedPayload, MessageDeltaPayload,
PROTOCOL_VERSION, SendMessageRequest, ServerCapabilities, ServerInfo, ToolResult,
};
use tokio::sync::broadcast::error::RecvError;
use crate::state::{AppState, FIXED_TIMESTAMP};
pub(crate) fn router(state: Arc<AppState>) -> Router {
Router::new()
.route("/desktop/v1/health", get(health))
.route("/desktop/v1/server-info", get(server_info))
.route("/desktop/v1/capabilities", get(capabilities))
.route("/desktop/v1/auth/login", post(auth_login))
.route("/desktop/v1/auth/refresh", post(auth_refresh))
.route("/desktop/v1/messages", post(send_message))
.route("/desktop/v1/events/stream", get(event_stream))
.route("/desktop/v1/events/{event_id}/ack", post(acknowledge_event))
.route(
"/desktop/v1/local-actions/{action_id}/accepted",
post(local_action_accepted),
)
.route(
"/desktop/v1/local-actions/{action_id}/rejected",
post(local_action_rejected),
)
.route(
"/desktop/v1/local-actions/{action_id}/progress",
post(local_action_progress),
)
.route(
"/desktop/v1/local-actions/{action_id}/result",
post(local_action_result),
)
.with_state(state)
}
async fn health(State(state): State<Arc<AppState>>) -> Json<HealthResponse> {
Json(HealthResponse {
status: "ok".to_owned(),
protocol_version: PROTOCOL_VERSION.to_owned(),
server_instance_id: state.server_instance_id.clone(),
})
}
async fn server_info(State(state): State<Arc<AppState>>) -> Json<ServerInfo> {
Json(ServerInfo {
server_instance_id: state.server_instance_id.clone(),
display_name: state.display_name.clone(),
server_version: "0.1.0-mock".to_owned(),
protocol_version: PROTOCOL_VERSION.to_owned(),
server_time: FIXED_TIMESTAMP.to_owned(),
})
}
async fn capabilities(State(state): State<Arc<AppState>>) -> Json<ServerCapabilities> {
Json(state.capabilities.clone())
}
async fn auth_login(
State(state): State<Arc<AppState>>,
Json(request): Json<AuthLoginRequest>,
) -> Response {
if state.auth_is_rejected()
|| request.client_id.trim().is_empty()
|| request.device_id.trim().is_empty()
|| request.credential.trim().is_empty()
{
return error_response(
StatusCode::UNAUTHORIZED,
"auth_rejected",
"mock authentication rejected",
false,
);
}
let (access_token, refresh_token) = state.issue_tokens().await;
Json(AuthLoginResponse {
access_token,
refresh_token: Some(refresh_token),
expires_in_seconds: 300,
})
.into_response()
}
async fn auth_refresh(
State(state): State<Arc<AppState>>,
Json(request): Json<AuthRefreshRequest>,
) -> Response {
let Some((access_token, refresh_token)) = state.refresh_tokens(&request.refresh_token).await
else {
return error_response(
StatusCode::UNAUTHORIZED,
"refresh_rejected",
"mock refresh rejected",
false,
);
};
Json(AuthLoginResponse {
access_token,
refresh_token: Some(refresh_token),
expires_in_seconds: 300,
})
.into_response()
}
async fn send_message(
State(state): State<Arc<AppState>>,
headers: HeaderMap,
Json(request): Json<SendMessageRequest>,
) -> Response {
if let Err(response) = require_auth(&state, &headers).await {
return response;
}
if request.conversation_id.trim().is_empty() || request.content.trim().is_empty() {
return error_response(
StatusCode::BAD_REQUEST,
"invalid_message",
"conversationId and content are required",
false,
);
}
let accepted = state.accept_message();
let reply = match state.instance {
crate::MockInstanceKind::Companion => "Deterministic companion response",
crate::MockInstanceKind::Operations => "Deterministic operations response",
};
let delta = state.create_event(
GatewayEventBody::MessageDelta(MessageDeltaPayload {
delta: reply.to_owned(),
index: 0,
}),
Some(accepted.request_id.clone()),
Some(request.conversation_id.clone()),
Some(accepted.message_id.clone()),
);
state.publish(delta).await;
let completed = state.create_event(
GatewayEventBody::MessageCompleted(MessageCompletedPayload {
finish_reason: FinishReason::Stop,
content: Some(reply.to_owned()),
}),
Some(accepted.request_id.clone()),
Some(request.conversation_id),
Some(accepted.message_id.clone()),
);
state.publish(completed).await;
(StatusCode::ACCEPTED, Json(accepted)).into_response()
}
async fn event_stream(State(state): State<Arc<AppState>>, headers: HeaderMap) -> Response {
if let Err(response) = require_auth(&state, &headers).await {
return response;
}
let last_event_id = headers
.get("last-event-id")
.and_then(|value| value.to_str().ok())
.map(str::to_owned);
let mut events = state.subscribe_events();
let mut disconnects = state.subscribe_disconnects();
let replay = state.events_after(last_event_id.as_deref()).await;
let stream = async_stream::stream! {
yield Ok::<Event, Infallible>(Event::default().comment("connected"));
for event in replay {
if let Some(frame) = to_sse_event(&event) {
yield Ok::<Event, Infallible>(frame);
}
}
loop {
tokio::select! {
result = disconnects.changed() => {
if result.is_ok() {
break;
}
}
result = events.recv() => {
match result {
Ok(event) => {
if let Some(frame) = to_sse_event(&event) {
yield Ok::<Event, Infallible>(frame);
}
}
Err(RecvError::Lagged(_)) => continue,
Err(RecvError::Closed) => break,
}
}
}
}
};
Sse::new(stream)
.keep_alive(
KeepAlive::new()
.interval(Duration::from_secs(15))
.text("keep-alive"),
)
.into_response()
}
async fn acknowledge_event(
State(state): State<Arc<AppState>>,
headers: HeaderMap,
Path(event_id): Path<String>,
) -> Response {
if let Err(response) = require_auth(&state, &headers).await {
return response;
}
if event_id.trim().is_empty() {
return error_response(
StatusCode::BAD_REQUEST,
"invalid_event_id",
"event id is required",
false,
);
}
state.acknowledge(event_id.clone()).await;
Json(EventAcknowledgement {
event_id,
acknowledged: true,
})
.into_response()
}
async fn local_action_accepted(
State(state): State<Arc<AppState>>,
headers: HeaderMap,
Path(action_id): Path<String>,
Json(decision): Json<LocalActionDecision>,
) -> Response {
validate_decision(
&state,
&headers,
&action_id,
&decision,
LocalActionDecisionKind::Accepted,
)
.await
}
async fn local_action_rejected(
State(state): State<Arc<AppState>>,
headers: HeaderMap,
Path(action_id): Path<String>,
Json(decision): Json<LocalActionDecision>,
) -> Response {
validate_decision(
&state,
&headers,
&action_id,
&decision,
LocalActionDecisionKind::Rejected,
)
.await
}
async fn validate_decision(
state: &AppState,
headers: &HeaderMap,
action_id: &str,
decision: &LocalActionDecision,
expected: LocalActionDecisionKind,
) -> Response {
if let Err(response) = require_auth(state, headers).await {
return response;
}
if decision.action_id != action_id || decision.decision != expected {
return error_response(
StatusCode::BAD_REQUEST,
"invalid_action_decision",
"path and decision payload do not match",
false,
);
}
StatusCode::NO_CONTENT.into_response()
}
async fn local_action_progress(
State(state): State<Arc<AppState>>,
headers: HeaderMap,
Path(action_id): Path<String>,
Json(progress): Json<LocalActionProgress>,
) -> Response {
if let Err(response) = require_auth(&state, &headers).await {
return response;
}
if progress.action_id != action_id {
return error_response(
StatusCode::BAD_REQUEST,
"invalid_action_progress",
"path and progress payload do not match",
false,
);
}
StatusCode::NO_CONTENT.into_response()
}
async fn local_action_result(
State(state): State<Arc<AppState>>,
headers: HeaderMap,
Path(action_id): Path<String>,
Json(result): Json<ToolResult>,
) -> Response {
if let Err(response) = require_auth(&state, &headers).await {
return response;
}
if result.action_id != action_id {
return error_response(
StatusCode::BAD_REQUEST,
"invalid_action_result",
"path and result payload do not match",
false,
);
}
StatusCode::NO_CONTENT.into_response()
}
async fn require_auth(state: &AppState, headers: &HeaderMap) -> Result<(), Response> {
let token = headers
.get(AUTHORIZATION)
.and_then(|value| value.to_str().ok())
.and_then(|value| value.strip_prefix("Bearer "))
.map(str::to_owned);
if state.is_authorized(token.as_deref()).await {
Ok(())
} else {
Err(error_response(
StatusCode::UNAUTHORIZED,
"unauthorized",
"valid bearer authentication is required",
false,
))
}
}
fn to_sse_event(event: &GatewayEvent) -> Option<Event> {
let data = serde_json::to_string(event).ok()?;
Some(
Event::default()
.id(event.metadata.event_id.clone())
.event(event.event_type())
.data(data),
)
}
fn error_response(status: StatusCode, code: &str, message: &str, retryable: bool) -> Response {
(
status,
Json(GatewayErrorResponse {
code: code.to_owned(),
message: message.to_owned(),
retryable,
}),
)
.into_response()
}