use std::sync::Arc;
use axum::Json;
use axum::extract::{Path, Query, State};
use axum::http::StatusCode;
use axum::response::IntoResponse;
use chrono::{DateTime, Utc};
use second_brain_adapters::markdown;
use second_brain_core::redact::redact_for_store;
use second_brain_core::schema::{AGENT_NOTE_SOURCE, EXPLICIT_SOURCES, Memory, MemoryType, Scope};
use second_brain_core::sqlite_store::{Principal, RetireOutcome, SqliteStore};
use second_brain_core::store::Store;
use serde::de::IntoDeserializer;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::{
MemoryResponse, bad_request, error_response, internal_error, parse_memory_type, retry_write,
to_response,
};
use crate::AppState;
use crate::associate::{LinkError, link};
#[derive(Deserialize)]
pub(super) struct RememberRequest {
content: String,
memory_type: Option<String>,
source: Option<String>,
related_to: Option<Vec<String>>,
project: Option<String>,
id: Option<String>,
session_at: Option<String>,
scope: Option<String>,
}
#[derive(Serialize)]
struct RememberResponse {
id: String,
memory_type: String,
#[serde(default)]
duplicate: bool,
project_updated: bool,
scope_updated: bool,
entities: usize,
}
pub(super) async fn remember(
State(state): State<Arc<AppState>>,
Json(req): Json<RememberRequest>,
) -> impl IntoResponse {
let memory_type = match req.memory_type.as_deref().map(parse_memory_type) {
None => MemoryType::Semantic,
Some(Ok(t)) => t,
Some(Err(message)) => return bad_request(message),
};
let source = req.source.unwrap_or_else(|| "api".to_string());
if let Err(message) = check_written_source("remember", &source) {
return bad_request(message);
}
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 scope = match req.scope.as_deref().map(parse_scope).transpose() {
Ok(scope) => scope,
Err(message) => return bad_request(message),
};
let content = redact_for_store(&req.content);
let related_to: Vec<String> = req
.related_to
.unwrap_or_default()
.iter()
.map(|n| redact_for_store(n))
.collect();
let project = req.project;
let result = tokio::task::spawn_blocking(move || -> anyhow::Result<RememberResponse> {
let sqlite = &state.sqlite;
if let Some(written) = replayed(sqlite, client_id, memory_type)? {
return Ok(remember_outcome(written));
}
if let Some(existing) =
sqlite.find_exact_duplicate_outside_source(&content, None, markdown::SOURCE)?
{
let project_updated = match project.as_deref() {
Some(p) => sqlite.refile_memory(existing.id, p)?,
None => false,
};
let scope_updated = match scope {
Some(scope) if scope != existing.scope => {
sqlite.set_memory_scope(existing.id, scope, &Principal::Owner)?
}
_ => false,
};
return Ok(RememberResponse {
duplicate: true,
project_updated,
scope_updated,
..RememberResponse::new(existing.id, existing.memory_type)
});
}
let mut memory = Memory::new(content, memory_type, source, String::new())
.with_project_path(project)
.with_machine_id(state.machine.id.clone());
memory.scope = scope.unwrap_or_default();
let written = store_explicit(&state, memory, client_id, session_at, &related_to)?;
Ok(remember_outcome(written))
})
.await;
match result {
Ok(Ok(response)) => Json(response).into_response(),
Ok(Err(e)) => (
StatusCode::INTERNAL_SERVER_ERROR,
Json(serde_json::json!({"error": e.to_string()})),
)
.into_response(),
Err(e) => (
StatusCode::INTERNAL_SERVER_ERROR,
Json(serde_json::json!({"error": e.to_string()})),
)
.into_response(),
}
}
impl RememberResponse {
fn new(id: Uuid, memory_type: MemoryType) -> Self {
Self {
id: id.to_string(),
memory_type: format!("{memory_type:?}").to_lowercase(),
duplicate: false,
project_updated: false,
scope_updated: false,
entities: 0,
}
}
}
fn remember_outcome(written: Written) -> RememberResponse {
match written {
Written::Stored {
id,
memory_type,
entities,
} => RememberResponse {
entities,
..RememberResponse::new(id, memory_type)
},
Written::Replayed { id, memory_type } => RememberResponse {
duplicate: true,
..RememberResponse::new(id, memory_type)
},
}
}
pub(super) enum Written {
Stored {
id: Uuid,
memory_type: MemoryType,
entities: usize,
},
Replayed { id: Uuid, memory_type: MemoryType },
}
pub(super) fn check_written_source(route: &str, source: &str) -> Result<(), String> {
let writable =
|s: &str| EXPLICIT_SOURCES.contains(&s) && s != markdown::SOURCE && s != AGENT_NOTE_SOURCE;
if writable(source) {
return Ok(());
}
let valid: Vec<&str> = EXPLICIT_SOURCES
.iter()
.copied()
.filter(|s| writable(s))
.collect();
Err(format!(
"{route} accepts only an explicit source ({}), not '{source}'",
valid.join(", ")
))
}
pub(super) fn parse_client_id(id: Option<&str>) -> Result<Option<Uuid>, String> {
id.map(Uuid::parse_str)
.transpose()
.map_err(|_| format!("invalid memory id: {}", id.unwrap_or_default()))
}
fn parse_scope(scope: &str) -> Result<Scope, String> {
Scope::deserialize(scope.into_deserializer()).map_err(|_: serde::de::value::Error| {
format!("unknown scope '{scope}'; valid values: private, shared")
})
}
pub(super) fn parse_session_at(at: Option<&str>) -> Result<Option<DateTime<Utc>>, String> {
at.map(DateTime::parse_from_rfc3339)
.transpose()
.map(|at| at.map(|at| at.with_timezone(&Utc)))
.map_err(|e| format!("invalid session_at: {e}"))
}
pub(super) fn replayed(
sqlite: &SqliteStore,
client_id: Option<Uuid>,
memory_type: MemoryType,
) -> anyhow::Result<Option<Written>> {
let Some(id) = client_id else {
return Ok(None);
};
if let Some(known) = sqlite.get_memory(id)? {
return Ok(Some(Written::Replayed {
id,
memory_type: known.memory_type,
}));
}
if sqlite.tombstone_exists(id)? {
return Ok(Some(Written::Replayed { id, memory_type }));
}
Ok(None)
}
pub(super) fn store_explicit(
state: &AppState,
mut memory: Memory,
client_id: Option<Uuid>,
session_at: Option<DateTime<Utc>>,
related_to: &[String],
) -> anyhow::Result<Written> {
if let Some(id) = client_id {
memory.id = id;
}
memory.session_at = Some(session_at.unwrap_or(memory.created_at));
if let Some(ref emb) = state.embedder
&& let Ok(embedding) = emb.embed(&memory.content)
{
memory.embedding = embedding;
}
let id = memory.id;
let memory_type = memory.memory_type;
if client_id.is_some() {
if !retry_write(|| state.sqlite.store_memory_if_absent(&memory))? {
let stored_type = state
.sqlite
.get_memory(id)?
.map_or(memory_type, |m| m.memory_type);
return Ok(Written::Replayed {
id,
memory_type: stored_type,
});
}
} else {
retry_write(|| state.store.store_memory(&memory))?;
}
let entities = retry_write(|| {
crate::mentions::link_mentions(state.store.as_ref(), id, &memory.content, related_to)
})?;
Ok(Written::Stored {
id,
memory_type,
entities,
})
}
#[derive(Deserialize)]
pub(super) struct AssociateRequest {
#[serde(alias = "from")]
from_id: String,
#[serde(alias = "to")]
to_id: String,
relation: String,
context: Option<String>,
}
pub(super) async fn associate(
State(state): State<Arc<AppState>>,
Json(req): Json<AssociateRequest>,
) -> impl IntoResponse {
let store = state.sqlite.clone();
let relation = req.relation.clone();
let result = tokio::task::spawn_blocking(move || {
link(&store, &req.from_id, &req.to_id, &req.relation, req.context)
})
.await;
match result {
Ok(Ok(linked)) => (
StatusCode::CREATED,
Json(serde_json::json!({
"from_id": linked.from_id,
"to_id": linked.to_id,
"relation": relation,
"superseded": linked.superseded,
})),
)
.into_response(),
Ok(Err(LinkError::BadRequest(message))) => bad_request(message),
Ok(Err(LinkError::NotFound(message))) => error_response(StatusCode::NOT_FOUND, message),
Ok(Err(LinkError::Conflict(message))) => error_response(StatusCode::CONFLICT, message),
Ok(Err(LinkError::Store(e))) => internal_error(e),
Err(e) => internal_error(e),
}
}
pub(super) async fn get_memory(
State(state): State<Arc<AppState>>,
Path(id): Path<String>,
) -> impl IntoResponse {
let uuid = match Uuid::parse_str(&id) {
Ok(u) => u,
Err(_) => return (StatusCode::BAD_REQUEST, "invalid uuid").into_response(),
};
let sqlite = state.sqlite.clone();
let result = tokio::task::spawn_blocking(move || sqlite.get_memory_full(uuid)).await;
let machine_names = state.store.get_all_machines().unwrap_or_default();
match result {
Ok(Ok(Some(m))) => {
state.health.memories_used(&[uuid], Utc::now());
Json(to_response(m, None, None, &machine_names)).into_response()
}
Ok(Ok(None)) => StatusCode::NOT_FOUND.into_response(),
Ok(Err(e)) => (
StatusCode::INTERNAL_SERVER_ERROR,
Json(serde_json::json!({"error": e.to_string()})),
)
.into_response(),
Err(e) => (
StatusCode::INTERNAL_SERVER_ERROR,
Json(serde_json::json!({"error": e.to_string()})),
)
.into_response(),
}
}
#[derive(Deserialize, Default)]
pub(super) struct ForgetParams {
#[serde(default)]
hard: bool,
reason: Option<String>,
}
const DEFAULT_FORGET_REASON: &str = "forgotten";
pub(super) async fn forget(
State(state): State<Arc<AppState>>,
Path(id): Path<String>,
Query(params): Query<ForgetParams>,
) -> impl IntoResponse {
let uuid = match Uuid::parse_str(&id) {
Ok(u) => u,
Err(_) => return bad_request(format!("invalid memory id: {id}")),
};
let store = state.sqlite.clone();
let reason = params
.reason
.filter(|r| !r.trim().is_empty())
.map(|r| redact_for_store(&r))
.unwrap_or_else(|| DEFAULT_FORGET_REASON.to_string());
let hard = params.hard;
let result = tokio::task::spawn_blocking(move || -> anyhow::Result<Option<&'static str>> {
if hard {
return Ok(store.remove_memory(uuid)?.then_some("deleted"));
}
Ok(match store.retire_memory(uuid, &reason)? {
RetireOutcome::Retired => Some("retired"),
RetireOutcome::AlreadyRetired => Some("already_retired"),
RetireOutcome::NotFound => None,
})
})
.await;
match result {
Ok(Ok(Some(action))) => {
Json(serde_json::json!({"id": uuid.to_string(), "action": action})).into_response()
}
Ok(Ok(None)) => error_response(StatusCode::NOT_FOUND, format!("no memory with id {uuid}")),
Ok(Err(e)) => internal_error(e),
Err(e) => internal_error(e),
}
}
#[derive(Deserialize)]
pub(super) struct TraverseParams {
start_id: String,
depth: Option<u32>,
}
pub(super) async fn traverse(
State(state): State<Arc<AppState>>,
Query(params): Query<TraverseParams>,
) -> impl IntoResponse {
let uuid = match Uuid::parse_str(¶ms.start_id) {
Ok(u) => u,
Err(_) => return (StatusCode::BAD_REQUEST, "invalid start_id").into_response(),
};
let depth = params.depth.unwrap_or(2);
let store = state.store.clone();
let result = tokio::task::spawn_blocking(move || store.traverse(uuid, depth)).await;
let machine_names = state.store.get_all_machines().unwrap_or_default();
match result {
Ok(Ok(results)) => {
let memories: Vec<MemoryResponse> = results
.into_iter()
.map(|(m, _)| to_response(m, None, None, &machine_names))
.collect();
Json(serde_json::json!({"memories": memories})).into_response()
}
Ok(Err(e)) => (
StatusCode::INTERNAL_SERVER_ERROR,
Json(serde_json::json!({"error": e.to_string()})),
)
.into_response(),
Err(e) => (
StatusCode::INTERNAL_SERVER_ERROR,
Json(serde_json::json!({"error": e.to_string()})),
)
.into_response(),
}
}