use std::sync::Arc;
use axum::Json;
use axum::extract::State;
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use chrono::Utc;
use second_brain_core::evidence::Evidence;
use second_brain_core::redact::redact_for_store;
use second_brain_core::schema::Memory;
use second_brain_core::sqlite_store::{CorrectRefusal, Corrected};
use second_brain_core::store::Store;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::memory::{check_written_source, parse_client_id, parse_session_at};
use super::{
bad_request, error_response, internal_error, memory_type_name, parse_memory_type, retry_write,
};
use crate::AppState;
#[derive(Deserialize)]
pub(super) struct CorrectRequest {
memory_id: String,
content: String,
evidence: String,
memory_type: Option<String>,
source: Option<String>,
id: Option<String>,
session_at: Option<String>,
}
#[derive(Serialize)]
struct CorrectResponse {
id: String,
corrects: String,
memory_type: String,
project_path: Option<String>,
replayed: bool,
}
pub(super) async fn correct(
State(state): State<Arc<AppState>>,
Json(req): Json<CorrectRequest>,
) -> Response {
let Ok(old_id) = Uuid::parse_str(&req.memory_id) else {
return bad_request(format!("invalid memory id: {}", req.memory_id));
};
let client_id = match parse_client_id(req.id.as_deref()) {
Ok(id) => id,
Err(message) => return bad_request(message),
};
let session_at = match parse_session_at(req.session_at.as_deref()) {
Ok(at) => at,
Err(message) => return bad_request(message),
};
let memory_type = match req
.memory_type
.as_deref()
.map(parse_memory_type)
.transpose()
{
Ok(t) => t,
Err(message) => return bad_request(message),
};
let source = req.source.unwrap_or_else(|| "api".to_string());
if let Err(message) = check_written_source("correct", &source) {
return bad_request(message);
}
let content = redact_for_store(req.content.trim());
if content.is_empty() {
return bad_request("content is required");
}
let evidence = match Evidence::parse(&req.evidence) {
Ok(evidence) => redact_for_store(&evidence.to_string()),
Err(e) => return bad_request(e),
};
let result = tokio::task::spawn_blocking(
move || -> anyhow::Result<Result<Corrected, CorrectRefusal>> {
let Some(old) = state.sqlite.get_memory(old_id)? else {
return Ok(Err(CorrectRefusal::NotFound));
};
let mut memory = Memory::new(
content,
memory_type.unwrap_or(old.memory_type),
source,
String::new(),
)
.with_machine_id(state.machine.id.clone());
if let Some(id) = client_id {
memory.id = id;
}
memory.session_at = Some(session_at.unwrap_or(memory.created_at));
if let Some(emb) = state.embedder.as_ref()
&& let Ok(embedding) = emb.embed(&memory.content)
{
memory.embedding = embedding;
}
let outcome = retry_write(|| {
state
.sqlite
.correct_memory(old_id, memory.clone(), &evidence)
})?;
if let Ok(corrected) = &outcome
&& !corrected.replayed
{
state.health.memory_corrected(old_id, Utc::now());
retry_write(|| {
crate::mentions::link_mentions(
state.store.as_ref(),
corrected.memory.id,
&corrected.memory.content,
&[],
)
})?;
}
Ok(outcome)
},
)
.await;
match result {
Ok(Ok(Ok(corrected))) => created(old_id, corrected),
Ok(Ok(Err(refusal))) => refused(old_id, refusal),
Ok(Err(e)) => internal_error(e),
Err(e) => internal_error(e),
}
}
fn created(old_id: Uuid, corrected: Corrected) -> Response {
(
StatusCode::CREATED,
Json(CorrectResponse {
id: corrected.memory.id.to_string(),
corrects: old_id.to_string(),
memory_type: memory_type_name(corrected.memory.memory_type),
project_path: corrected.memory.project_path,
replayed: corrected.replayed,
}),
)
.into_response()
}
fn refused(old_id: Uuid, refusal: CorrectRefusal) -> Response {
match refusal {
CorrectRefusal::NotFound => {
error_response(StatusCode::NOT_FOUND, format!("no memory with id {old_id}"))
}
CorrectRefusal::Retired => {
error_response(StatusCode::CONFLICT, format!("memory {old_id} is retired"))
}
CorrectRefusal::AlreadyCorrected { current } => (
StatusCode::CONFLICT,
Json(serde_json::json!({
"error": format!(
"memory {old_id} was already corrected; its current replacement is {current}"
),
"current": current.to_string(),
})),
)
.into_response(),
CorrectRefusal::IdTaken => error_response(
StatusCode::CONFLICT,
"the replacement id is already used by another memory",
),
}
}