second-brain-api 0.13.5

HTTP API server for second-brain: REST endpoints for recall, remember, and ingest
Documentation
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>,
    /// The replacement's client id, so a queued call replays as a no-op.
    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",
        ),
    }
}