feat(memory): add durable conversation memory backend

Cargo.toml

@@ -24,6 +24,7 @@ members = [
     "crates/aionui-project",
     "crates/aionui-cron",
     "crates/aionui-assistant",
+    "crates/aionui-memory",
     "crates/aionui-app",
 ]
 
@@ -57,6 +58,7 @@ aionui-team = { path = "crates/aionui-team" }
 aionui-project = { path = "crates/aionui-project" }
 aionui-cron = { path = "crates/aionui-cron" }
 aionui-assistant = { path = "crates/aionui-assistant" }
+aionui-memory = { path = "crates/aionui-memory" }
 aionui-app = { path = "crates/aionui-app" }
 
 aion-agent = { git = "https://github.com/iOfficeAI/aionrs.git", tag = "v0.2.8" }
@@ -77,6 +79,7 @@ http = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"
+unicode-normalization = "0.1"
 
 # Async utilities
 futures-util = "0.3"

crates/aionui-ai-agent/src/lib.rs

@@ -59,6 +59,7 @@ pub use runtime_token::{
 };
 pub use services::AgentAvailabilityFeedbackPort;
 pub use services::AgentService;
+pub use services::ProviderHealthChecker;
 pub use services::RemoteAgentService;
 pub use session_context::{
     AcpSessionBuildContext, AgentSessionContext, AgentSessionKind, AionrsSessionBuildContext, ConversationContext,

crates/aionui-ai-agent/src/routes/agent.rs

@@ -13,9 +13,9 @@ use axum::extract::{Extension, Json, Path, State};
 use axum::routing::{get, patch, post, put};
 
 use aionui_api_types::{
-    AgentLogoEntry, AgentManagementRow, AgentMetadata, AgentOverridesResponse, ApiResponse, CustomAgentUpsertRequest,
-    DeleteCustomAgentResponse, ProviderHealthCheckRequest, ProviderHealthCheckResponse, SetAgentOverridesRequest,
-    SetEnabledRequest, TryConnectCustomAgentRequest, TryConnectCustomAgentResponse,
+    AgentLogoEntry, AgentManagementRow, AgentMetadata, AgentOverridesResponse, ApiResponse, AppOperationsModelResponse,
+    CustomAgentUpsertRequest, DeleteCustomAgentResponse, ProviderHealthCheckRequest, ProviderHealthCheckResponse,
+    SetAgentOverridesRequest, SetEnabledRequest, TryConnectCustomAgentRequest, TryConnectCustomAgentResponse,
 };
 use aionui_auth::CurrentUser;
 use aionui_common::ApiError;
@@ -29,6 +29,7 @@ pub fn agent_routes(state: AgentRouterState) -> Router {
         .route("/api/agents/management", get(list_management_agents))
         .route("/api/agents/{id}/health-check", post(health_check_by_id))
         .route("/api/agents/provider-health-check", post(provider_health_check))
+        .route("/api/app-operations/model/check", post(check_app_operations_model))
         .route("/api/agents/{id}/enabled", patch(set_agent_enabled))
         .route(
             "/api/agents/{id}/overrides",
@@ -40,6 +41,19 @@ pub fn agent_routes(state: AgentRouterState) -> Router {
         .with_state(state)
 }
 
+async fn check_app_operations_model(
+    State(state): State<AgentRouterState>,
+    Extension(_user): Extension<CurrentUser>,
+) -> Result<Json<ApiResponse<AppOperationsModelResponse>>, ApiError> {
+    Ok(Json(ApiResponse::ok(
+        state
+            .service
+            .check_app_operations_model()
+            .await
+            .map_err(agent_error_to_api_error)?,
+    )))
+}
+
 async fn list_agent_logos(
     State(state): State<AgentRouterState>,
     Extension(_user): Extension<CurrentUser>,

crates/aionui-ai-agent/src/services/agent.rs

@@ -14,20 +14,28 @@
 
 use std::path::PathBuf;
 use std::sync::Arc;
+use std::time::Instant;
 
-use aionui_api_types::{AgentLogoEntry, AgentManagementRow, ProviderHealthCheckRequest, ProviderHealthCheckResponse};
+use aionui_api_types::{
+    AgentLogoEntry, AgentManagementRow, AppOperationsModelHealth, AppOperationsModelResponse, HealthStatus,
+    ProviderHealthCheckRequest, ProviderHealthCheckResponse,
+};
+use aionui_common::now_ms;
 use aionui_db::IProviderRepository;
 use aionui_realtime::EventBroadcaster;
+use aionui_system::SettingsService;
+use tracing::info;
 
 use super::availability::{AgentAvailabilityFeedbackPort, AgentAvailabilityService};
-use super::provider_health::ProviderHealthCheckService;
+use super::provider_health::{ProviderHealthCheckService, ProviderHealthChecker};
 use crate::error::AgentError;
 use crate::registry::AgentRegistry;
 
 pub struct AgentService {
     registry: Arc<AgentRegistry>,
     broadcaster: Arc<dyn EventBroadcaster>,
-    provider_health: ProviderHealthCheckService,
+    provider_health: Arc<dyn ProviderHealthChecker>,
+    app_operations_settings: SettingsService,
     availability: AgentAvailabilityService,
 }
 
@@ -38,17 +46,34 @@ impl AgentService {
         provider_repo: Arc<dyn IProviderRepository>,
         encryption_key: [u8; 32],
         data_dir: PathBuf,
+        app_operations_settings: SettingsService,
     ) -> Arc<Self> {
-        let provider_health = ProviderHealthCheckService::new(provider_repo.clone(), encryption_key, data_dir.clone());
+        let provider_health = Arc::new(ProviderHealthCheckService::new(
+            provider_repo.clone(),
+            encryption_key,
+            data_dir.clone(),
+        ));
         let availability = AgentAvailabilityService::new(registry.clone(), provider_repo);
         Arc::new(Self {
             registry,
             broadcaster,
             provider_health,
+            app_operations_settings,
             availability,
         })
     }
 
+    #[doc(hidden)]
+    pub fn with_provider_health_checker(&self, provider_health: Arc<dyn ProviderHealthChecker>) -> Arc<Self> {
+        Arc::new(Self {
+            registry: self.registry.clone(),
+            broadcaster: self.broadcaster.clone(),
+            provider_health,
+            app_operations_settings: self.app_operations_settings.clone(),
+            availability: self.availability.clone(),
+        })
+    }
+
     /// Registry accessor consumed by the `services::custom` submodule
     /// for direct repository access (upsert / delete / enable toggle).
     pub(crate) fn registry(&self) -> &Arc<AgentRegistry> {
@@ -113,6 +138,59 @@ impl AgentService {
         self.provider_health.health_check(req).await
     }
 
+    pub async fn check_app_operations_model(&self) -> Result<AppOperationsModelResponse, AgentError> {
+        let started = Instant::now();
+        let result = self.check_app_operations_model_inner().await;
+        let status = result
+            .as_ref()
+            .map(|response| app_operations_health_label(response.health))
+            .unwrap_or("error");
+        info!(
+            status,
+            duration_ms = started.elapsed().as_millis(),
+            "App Operations model health check completed"
+        );
+        result
+    }
+
+    async fn check_app_operations_model_inner(&self) -> Result<AppOperationsModelResponse, AgentError> {
+        let current = self
+            .app_operations_settings
+            .get_app_operations_model()
+            .await
+            .map_err(|_| AgentError::internal("Failed to resolve App Operations model"))?;
+        let Some(resolved) = current.resolved_model else {
+            return Ok(current);
+        };
+
+        let response = self
+            .provider_health
+            .health_check(ProviderHealthCheckRequest {
+                provider_id: resolved.provider_id.clone(),
+                model: resolved.model_id.clone(),
+            })
+            .await?;
+        let status = match response.status {
+            HealthStatus::Healthy => HealthStatus::Healthy,
+            HealthStatus::Unhealthy | HealthStatus::Unknown => HealthStatus::Unhealthy,
+        };
+        self.app_operations_settings
+            .record_app_operations_health(
+                &resolved.provider_id,
+                &resolved.model_id,
+                status,
+                now_ms(),
+                response.elapsed_ms.try_into().unwrap_or(i64::MAX),
+            )
+            .await
+            .map_err(|_| AgentError::internal("Failed to record App Operations model health"))?;
+
+        self.app_operations_settings
+            .get_app_operations_model()
+            .await
+            .map_err(|_| AgentError::internal("Failed to refresh App Operations model health"))
+    }
+
     pub async fn set_agent_overrides(
         &self,
         id: &str,
@@ -192,6 +270,15 @@ impl AgentService {
     }
 }
 
+fn app_operations_health_label(health: AppOperationsModelHealth) -> &'static str {
+    match health {
+        AppOperationsModelHealth::Ready => "ready",
+        AppOperationsModelHealth::Checking => "checking",
+        AppOperationsModelHealth::SetupRequired => "setup_required",
+        AppOperationsModelHealth::Unavailable => "unavailable",
+    }
+}
+
 /// True when the row is launched through a bridge binary (e.g. `npx`) rather
 /// than a direct CLI. Such rows store the bridge's own arguments in `args`
 /// (e.g. `-y <package> acp`), so replacing `command` with a launch path would

crates/aionui-ai-agent/src/services/mod.rs

@@ -6,4 +6,5 @@ pub mod remote;
 
 pub use agent::AgentService;
 pub use availability::AgentAvailabilityFeedbackPort;
+pub use provider_health::ProviderHealthChecker;
 pub use remote::RemoteAgentService;

crates/aionui-ai-agent/src/services/provider_health.rs

@@ -33,6 +33,14 @@ pub struct ProviderHealthCheckService {
     data_dir: PathBuf,
 }
 
+#[async_trait::async_trait]
+pub trait ProviderHealthChecker: Send + Sync {
+    async fn health_check(
+        &self,
+        request: ProviderHealthCheckRequest,
+    ) -> Result<ProviderHealthCheckResponse, AgentError>;
+}
+
 impl ProviderHealthCheckService {
     pub fn new(provider_repo: Arc<dyn IProviderRepository>, encryption_key: [u8; 32], data_dir: PathBuf) -> Self {
         Self {
@@ -108,6 +116,16 @@ impl ProviderHealthCheckService {
     }
 }
 
+#[async_trait::async_trait]
+impl ProviderHealthChecker for ProviderHealthCheckService {
+    async fn health_check(
+        &self,
+        request: ProviderHealthCheckRequest,
+    ) -> Result<ProviderHealthCheckResponse, AgentError> {
+        ProviderHealthCheckService::health_check(self, request).await
+    }
+}
+
 async fn run_probe(
     provider_id: String,
     platform: String,