1use async_trait::async_trait;
16use infinity_agent_core::ThreadId;
17use infinity_agent_core::message::InfinityMessage;
18use infinity_agent_core::stores::{
19 self as core_stores, CompactionSummary, ThreadInfo, ThreadState,
20};
21use infinity_agent_core::system::UserChoice;
22use infinity_agent_core::traits::{ConversationStore, SpawnContext, StateStore};
23use infinity_protocol::ModelRef;
24use infinity_provider_protocol::message::Message;
25use serde::{Deserialize, Serialize};
26use std::collections::{HashMap, HashSet};
27use std::path::{Path, PathBuf};
28use std::sync::{Arc, Mutex};
29
30#[derive(Debug)]
33pub struct MemoryError(pub String);
34impl std::fmt::Display for MemoryError {
35 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
36 write!(f, "{}", self.0)
37 }
38}
39impl std::error::Error for MemoryError {}
40
41impl From<core_stores::InMemoryStoreError> for MemoryError {
42 fn from(e: core_stores::InMemoryStoreError) -> Self {
43 MemoryError(e.to_string())
44 }
45}
46
47#[derive(Clone)]
50pub struct PersistentConversationStore {
51 core: core_stores::InMemoryConversationStore,
53 extras: Arc<Mutex<HashMap<ThreadId, ThreadExtras>>>,
57 dir: Option<PathBuf>,
59 loaded: Arc<Mutex<HashSet<ThreadId>>>,
61 metadata_loaded: Arc<Mutex<HashSet<ThreadId>>>,
63 change_tx: Option<tokio::sync::mpsc::UnboundedSender<ThreadId>>,
65 views: Arc<Mutex<HashMap<ThreadId, HashMap<String, serde_json::Value>>>>,
68 default_model: ModelRef,
71 id_source: Arc<dyn crate::ids::IdSource>,
73}
74
75#[derive(Clone, Serialize, Deserialize)]
78pub(crate) struct ThreadExtras {
79 #[serde(default)]
80 title: Option<String>,
81 #[serde(default)]
82 children: Vec<ThreadId>,
83 #[serde(default)]
84 total_tokens_used: usize,
85 #[serde(default)]
86 last_updated: String,
87 #[serde(default = "unset_model_ref")]
93 selected_model: ModelRef,
94}
95
96impl ThreadExtras {
97 fn new(selected_model: ModelRef) -> Self {
98 Self {
99 title: None,
100 children: Vec::new(),
101 total_tokens_used: 0,
102 last_updated: String::new(),
103 selected_model,
104 }
105 }
106}
107
108#[derive(Clone, Serialize, Deserialize)]
114pub(crate) struct ThreadMeta {
115 #[serde(flatten)]
116 pub(crate) info: ThreadInfo,
117 #[serde(flatten)]
118 pub(crate) extras: ThreadExtras,
119}
120
121fn unset_model_ref() -> ModelRef {
126 ModelRef {
127 provider_id: String::new(),
128 model_id: String::new(),
129 }
130}
131
132#[derive(Serialize)]
134pub(crate) struct ThreadSnapshot {
135 messages: Vec<(InfinityMessage, String)>,
136 #[serde(default)]
137 compaction_summaries: Vec<CompactionSummary>,
138}
139
140#[derive(Deserialize)]
142struct NewThreadSnapshot {
143 messages: Vec<(InfinityMessage, String)>,
144 #[serde(default)]
145 compaction_summaries: Vec<CompactionSummary>,
146}
147
148#[derive(Deserialize)]
150struct OldThreadSnapshot {
151 #[serde(default)]
152 messages: Vec<(Message, String)>,
153 #[serde(default, deserialize_with = "deserialize_legacy_display_as_map")]
154 display_as: HashMap<String, Vec<rap_protocol::DisplaySegment>>,
155 #[serde(default)]
156 compaction_summaries: Vec<CompactionSummary>,
157}
158
159impl<'de> Deserialize<'de> for ThreadSnapshot {
162 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
163 where
164 D: serde::Deserializer<'de>,
165 {
166 let raw: serde_json::Value = Deserialize::deserialize(deserializer)?;
167
168 if let Ok(new) = serde_json::from_value::<NewThreadSnapshot>(raw.clone()) {
170 return Ok(ThreadSnapshot {
171 messages: new.messages,
172 compaction_summaries: new.compaction_summaries,
173 });
174 }
175
176 let old: OldThreadSnapshot =
177 serde_json::from_value(raw).map_err(serde::de::Error::custom)?;
178
179 let messages = old
180 .messages
181 .into_iter()
182 .map(|(msg, id)| {
183 let mut inf = InfinityMessage::from_message(msg);
184 if let InfinityMessage::ToolResult {
185 ref result,
186 ref mut display_segments,
187 } = inf
188 && let Some(segs) = old.display_as.get(&result.id)
189 {
190 *display_segments = Some(segs.clone());
191 }
192 (inf, id)
193 })
194 .collect();
195
196 Ok(ThreadSnapshot {
197 messages,
198 compaction_summaries: old.compaction_summaries,
199 })
200 }
201}
202
203fn deserialize_legacy_display_as_map<'de, D>(
205 deserializer: D,
206) -> Result<HashMap<String, Vec<rap_protocol::DisplaySegment>>, D::Error>
207where
208 D: serde::Deserializer<'de>,
209{
210 let raw: HashMap<String, serde_json::Value> = HashMap::deserialize(deserializer)?;
211 let mut result = HashMap::new();
212 for (k, v) in raw {
213 let segments = match v {
214 serde_json::Value::String(s) => vec![rap_protocol::DisplaySegment::Text(s)],
215 serde_json::Value::Array(_) => {
216 serde_json::from_value(v).map_err(serde::de::Error::custom)?
217 }
218 _ => continue,
219 };
220 result.insert(k, segments);
221 }
222 Ok(result)
223}
224
225#[derive(Serialize, Deserialize)]
226pub(crate) struct SerializedThread {
227 pub metadata: ThreadMeta,
228 pub snapshot: ThreadSnapshot,
229 #[serde(default)]
230 pub views: HashMap<String, serde_json::Value>,
231}
232
233impl PersistentConversationStore {
234 pub fn new_with_dir(
239 dir: impl AsRef<Path>,
240 default_model: ModelRef,
241 id_source: Arc<dyn crate::ids::IdSource>,
242 ) -> Self {
243 let dir = dir.as_ref().to_path_buf();
244 std::fs::create_dir_all(&dir).ok();
245 Self {
246 core: core_stores::InMemoryConversationStore::new(),
247 extras: Arc::new(Mutex::new(HashMap::new())),
248 dir: Some(dir),
249 loaded: Arc::new(Mutex::new(HashSet::new())),
250 metadata_loaded: Arc::new(Mutex::new(HashSet::new())),
251 change_tx: None,
252 views: Arc::new(Mutex::new(HashMap::new())),
253 default_model,
254 id_source,
255 }
256 }
257
258 fn backfill_selected_model(&self, extras: &mut ThreadExtras) {
261 if extras.selected_model.provider_id.is_empty() {
262 extras.selected_model = self.default_model.clone();
263 }
264 }
265
266 pub fn set_change_tx(&mut self, tx: tokio::sync::mpsc::UnboundedSender<ThreadId>) {
268 self.change_tx = Some(tx);
269 }
270
271 fn migrate_from_session_store(&self, thread_id: &ThreadId<str>, threads_dir: &Path) {
274 {
275 let extras = self.extras.lock().expect("bug: mutex poisoned");
276 match extras.get(thread_id) {
277 Some(e) if e.last_updated.is_empty() => {}
278 _ => return,
279 }
280 }
281
282 let sessions_path = threads_dir.join("../sessions.json");
283 let Ok(json) = std::fs::read_to_string(&sessions_path) else {
284 return;
285 };
286 let Ok(val) = serde_json::from_str::<serde_json::Value>(&json) else {
287 return;
288 };
289 let Some(entry) = val.get("sessions").and_then(|s| s.get(thread_id.as_str())) else {
290 return;
291 };
292
293 let last_updated = entry
294 .get("last_updated")
295 .and_then(|v| v.as_str())
296 .unwrap_or("")
297 .to_owned();
298 let total_tokens_used = entry
299 .get("total_tokens_used")
300 .and_then(|v| v.as_u64())
301 .unwrap_or(0) as usize;
302
303 if last_updated.is_empty() && total_tokens_used == 0 {
304 return;
305 }
306
307 {
308 let mut extras = self.extras.lock().expect("bug: mutex poisoned");
309 if let Some(e) = extras.get_mut(thread_id) {
310 e.last_updated = last_updated;
311 e.total_tokens_used = total_tokens_used;
312 }
313 }
314 self.save_thread_metadata(thread_id);
315 }
316
317 fn notify_session(&self, thread_id: &ThreadId<str>) {
319 if let Some(ref tx) = self.change_tx {
320 let root = self.get_root_thread_id(thread_id);
321 let _ = tx.send(root);
322 }
323 }
324
325 fn thread_meta(&self, thread_id: &ThreadId<str>) -> Option<ThreadMeta> {
328 let info = self.core.thread_info(thread_id)?;
329 let extras = self
330 .extras
331 .lock()
332 .expect("bug: mutex poisoned")
333 .get(thread_id)
334 .cloned()?;
335 Some(ThreadMeta { info, extras })
336 }
337
338 fn restore_thread_meta(&self, thread_id: &ThreadId<str>, mut meta: ThreadMeta) {
341 self.backfill_selected_model(&mut meta.extras);
342 self.core.set_thread_info(thread_id, meta.info);
343 self.extras
344 .lock()
345 .expect("bug: mutex poisoned")
346 .insert(thread_id.to_owned(), meta.extras);
347 }
348
349 fn save_thread_metadata(&self, thread_id: &ThreadId<str>) {
351 let Some(ref dir) = self.dir else { return };
352 if let Some(meta) = self.thread_meta(thread_id) {
353 let path = dir.join(format!("{}.meta.json", thread_id));
354 if let Ok(json) = serde_json::to_string_pretty(&meta) {
355 std::fs::write(path, json).ok();
356 }
357 }
358 }
359
360 fn save_thread(&self, thread_id: &ThreadId<str>) {
363 let Some(ref dir) = self.dir else { return };
364 let snapshot = ThreadSnapshot {
365 messages: self.core.thread_messages(thread_id).unwrap_or_default(),
366 compaction_summaries: self.core.thread_compaction_summaries(thread_id),
367 };
368
369 let path = dir.join(format!("{}.json", thread_id));
370 if let Ok(json) = serde_json::to_string_pretty(&snapshot) {
371 std::fs::write(path, json).ok();
372 }
373 self.save_thread_metadata(thread_id);
374 }
375
376 fn ensure_thread_metadata_loaded(&self, thread_id: &ThreadId<str>) {
380 let Some(ref dir) = self.dir else { return };
381
382 let mut meta_loaded = self.metadata_loaded.lock().expect("bug: mutex poisoned");
383 if meta_loaded.contains(thread_id) {
384 return;
385 }
386
387 let already_in_memory = self.core.thread_info(thread_id).is_some();
390
391 let meta_path = dir.join(format!("{}.meta.json", thread_id));
393 if let Ok(json) = std::fs::read_to_string(&meta_path)
394 && let Ok(meta) = serde_json::from_str::<ThreadMeta>(&json)
395 {
396 if !already_in_memory {
397 self.restore_thread_meta(thread_id, meta);
398 }
399 } else {
400 let full_path = dir.join(format!("{}.json", thread_id));
402 if let Ok(json) = std::fs::read_to_string(&full_path)
403 && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json)
404 && let Some(info_val) = val.get("thread_info")
405 && let Ok(meta) = serde_json::from_value::<ThreadMeta>(info_val.clone())
406 && !already_in_memory
407 {
408 self.restore_thread_meta(thread_id, meta);
409 self.save_thread_metadata(thread_id);
411 }
412 }
413
414 self.migrate_from_session_store(thread_id, dir);
416
417 meta_loaded.insert(thread_id.to_owned());
418 }
419
420 fn ensure_thread_loaded(&self, thread_id: &ThreadId<str>) {
423 self.ensure_thread_metadata_loaded(thread_id);
424
425 let Some(ref dir) = self.dir else { return };
426
427 let mut loaded = self.loaded.lock().expect("bug: mutex poisoned");
428 if loaded.contains(thread_id) {
429 return;
430 }
431
432 let path = dir.join(format!("{}.json", thread_id));
433 if let Ok(json) = std::fs::read_to_string(&path)
434 && let Ok(snapshot) = serde_json::from_str::<ThreadSnapshot>(&json)
435 {
436 assert!(
437 !self.core.set_thread_messages(thread_id, snapshot.messages),
438 "bug: thread {thread_id} messages loaded twice"
439 );
440 assert!(
441 !self
442 .core
443 .set_thread_compaction_summaries(thread_id, snapshot.compaction_summaries),
444 "bug: thread {thread_id} compaction summaries loaded twice"
445 );
446 }
447
448 loaded.insert(thread_id.to_owned());
449
450 self.load_views(thread_id);
451 }
452
453 pub fn has_thread(&self, thread_id: &ThreadId<str>) -> bool {
455 self.ensure_thread_metadata_loaded(thread_id);
456 self.core.thread_info(thread_id).is_some()
457 }
458
459 pub fn get_root_thread_id(&self, thread_id: &ThreadId<str>) -> ThreadId {
461 self.ensure_thread_metadata_loaded(thread_id);
462 self.core
463 .thread_info(thread_id)
464 .map(|t| t.root_thread_id)
465 .unwrap_or_else(|| thread_id.to_owned())
466 }
467
468 pub fn get_thread_parent_id(&self, thread_id: &ThreadId<str>) -> Option<ThreadId> {
470 self.ensure_thread_metadata_loaded(thread_id);
471 self.core
472 .thread_info(thread_id)
473 .and_then(|t| t.parent_thread_id)
474 }
475
476 pub fn set_thread_title(&self, thread_id: &ThreadId<str>, title: &str) {
478 self.ensure_thread_metadata_loaded(thread_id);
479 {
480 let mut extras = self.extras.lock().expect("bug: mutex poisoned");
481 if let Some(e) = extras.get_mut(thread_id) {
482 e.title = Some(title.to_owned());
483 }
484 }
485 self.save_thread_metadata(thread_id);
486 self.notify_session(thread_id);
487 }
488
489 pub fn get_thread_model(&self, thread_id: &ThreadId<str>) -> ModelRef {
492 self.ensure_thread_metadata_loaded(thread_id);
493 let extras = self.extras.lock().expect("bug: mutex poisoned");
494 extras
495 .get(thread_id)
496 .map(|e| e.selected_model.clone())
497 .expect("bug: thread metadata missing in get_thread_model")
498 }
499
500 pub fn set_thread_model(&self, thread_id: &ThreadId<str>, model: ModelRef) {
502 self.ensure_thread_metadata_loaded(thread_id);
503 {
504 let mut extras = self.extras.lock().expect("bug: mutex poisoned");
505 if let Some(e) = extras.get_mut(thread_id) {
506 e.selected_model = model;
507 }
508 }
509 self.save_thread_metadata(thread_id);
510 }
511
512 pub fn get_session_thread_ids(&self, root_id: &ThreadId<str>) -> Vec<ThreadId> {
517 let mut result = Vec::new();
518 let mut queue = vec![root_id.to_owned()];
519 let mut visited = HashSet::new();
520
521 while let Some(thread_id) = queue.pop() {
522 if !visited.insert(thread_id.to_owned()) {
523 continue;
524 }
525 self.ensure_thread_metadata_loaded(&thread_id);
526 let children = {
527 let extras = self.extras.lock().expect("bug: mutex poisoned");
528 extras
529 .get(&thread_id)
530 .map(|entry| entry.children.clone())
531 .unwrap_or_default()
532 };
533 result.push(thread_id);
534 queue.extend(children);
535 }
536
537 result
538 }
539
540 pub fn get_open_subthreads(
543 &self,
544 parent_id: &ThreadId<str>,
545 ) -> Vec<infinity_protocol::SubthreadInfo> {
546 self.ensure_thread_metadata_loaded(parent_id);
547 let mut result = Vec::new();
548 let mut queue = vec![parent_id.to_owned()];
549 while let Some(pid) = queue.pop() {
550 let children = {
551 let extras = self.extras.lock().expect("bug: mutex poisoned");
552 extras
553 .get(&pid)
554 .map(|e| e.children.clone())
555 .unwrap_or_default()
556 };
557 for child_id in children {
558 self.ensure_thread_metadata_loaded(&child_id);
559 let Some(info) = self.core.thread_info(&child_id) else {
560 continue;
561 };
562 if !info.closed && !info.is_compaction {
563 let title = {
564 let extras = self.extras.lock().expect("bug: mutex poisoned");
565 extras.get(&child_id).and_then(|e| e.title.clone())
566 };
567 result.push(infinity_protocol::SubthreadInfo {
568 thread_id: infinity_protocol::ThreadRef::local(child_id.clone()),
569 parent_thread_id: infinity_protocol::ThreadRef::local(pid.clone()),
570 title,
571 });
572 queue.push(child_id);
573 }
574 }
575 }
576 result
577 }
578
579 pub fn get_total_tokens_used(&self, thread_id: &ThreadId<str>) -> usize {
580 self.ensure_thread_metadata_loaded(thread_id);
581 self.extras
582 .lock()
583 .expect("bug: mutex poisoned")
584 .get(thread_id)
585 .map(|e| e.total_tokens_used)
586 .unwrap_or(0)
587 }
588
589 pub fn set_total_tokens_used(&self, thread_id: &ThreadId<str>, tokens: usize) {
590 self.ensure_thread_metadata_loaded(thread_id);
591 if let Some(e) = self
592 .extras
593 .lock()
594 .expect("bug: mutex poisoned")
595 .get_mut(thread_id)
596 {
597 e.total_tokens_used = tokens;
598 }
599 self.save_thread_metadata(thread_id);
600 self.notify_session(thread_id);
601 }
602
603 pub fn get_last_updated(&self, thread_id: &ThreadId<str>) -> String {
604 self.ensure_thread_metadata_loaded(thread_id);
605 self.extras
606 .lock()
607 .expect("bug: mutex poisoned")
608 .get(thread_id)
609 .map(|e| e.last_updated.clone())
610 .unwrap_or_default()
611 }
612
613 pub fn set_last_updated(&self, thread_id: &ThreadId<str>, ts: &str) {
614 self.ensure_thread_metadata_loaded(thread_id);
615 if let Some(e) = self
616 .extras
617 .lock()
618 .expect("bug: mutex poisoned")
619 .get_mut(thread_id)
620 {
621 e.last_updated = ts.to_owned();
622 }
623 self.save_thread_metadata(thread_id);
624 }
625
626 fn save_views(&self, thread_id: &ThreadId<str>) {
628 let Some(ref dir) = self.dir else { return };
629 let views = self.views.lock().expect("bug: mutex poisoned");
630 let path = dir.join(format!("{}.views.json", thread_id));
631 match views.get(thread_id) {
632 Some(v) if !v.is_empty() => {
633 if let Ok(json) = serde_json::to_string_pretty(v) {
634 std::fs::write(path, json).ok();
635 }
636 }
637 _ => {
638 let _ = std::fs::remove_file(path); }
640 }
641 }
642
643 fn load_views(&self, thread_id: &ThreadId<str>) {
645 tracing::info!("Loading views for thread {thread_id}");
646 let Some(ref dir) = self.dir else { return };
647 let path = dir.join(format!("{}.views.json", thread_id));
648 match std::fs::read_to_string(&path) {
649 Ok(json) => match serde_json::from_str::<HashMap<String, serde_json::Value>>(&json) {
650 Ok(v) => {
651 self.views
652 .lock()
653 .expect("bug: mutex poisoned")
654 .insert(thread_id.to_owned(), v);
655 }
656 Err(e) => {
657 tracing::error!("Failed to deserialize views: {e}");
658 }
659 },
660 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {} Err(e) => {
662 tracing::error!("Failed to load views file: {e}");
663 }
664 }
665 }
666
667 pub fn set_view(&self, thread_id: &ThreadId<str>, view_type: &str, content: serde_json::Value) {
669 {
670 let mut views = self.views.lock().expect("bug: mutex poisoned");
671 views
672 .entry(thread_id.to_owned())
673 .or_default()
674 .insert(view_type.to_owned(), content);
675 }
676 self.save_views(thread_id);
677 }
678
679 pub fn get_views(&self, thread_id: &ThreadId<str>) -> HashMap<String, serde_json::Value> {
681 self.ensure_thread_loaded(thread_id);
682 self.views
683 .lock()
684 .expect("bug: mutex poisoned")
685 .get(thread_id)
686 .cloned()
687 .unwrap_or_default()
688 }
689
690 pub fn get_thread_title(&self, thread_id: &ThreadId<str>) -> Option<String> {
691 self.ensure_thread_metadata_loaded(thread_id);
692 self.extras
693 .lock()
694 .expect("bug: mutex poisoned")
695 .get(thread_id)
696 .and_then(|e| e.title.clone())
697 }
698
699 pub fn serialize_session(&self, root_thread_id: &ThreadId<str>) -> String {
701 let mut threads: HashMap<ThreadId, SerializedThread> = HashMap::new();
702 let mut queue = vec![root_thread_id.to_owned()];
703 while let Some(tid) = queue.pop() {
704 self.ensure_thread_loaded(&tid);
705 let Some(metadata) = self.thread_meta(&tid) else {
706 continue;
707 };
708 queue.extend(metadata.extras.children.clone());
709 let snapshot = ThreadSnapshot {
710 messages: self.core.thread_messages(&tid).unwrap_or_default(),
711 compaction_summaries: self.core.thread_compaction_summaries(&tid),
712 };
713 let views = self
714 .views
715 .lock()
716 .expect("bug: mutex poisoned")
717 .get(&tid)
718 .cloned()
719 .unwrap_or_default();
720 threads.insert(
721 tid,
722 SerializedThread {
723 metadata,
724 snapshot,
725 views,
726 },
727 );
728 }
729 serde_json::to_string(&threads).expect("bug: serde serialization failed")
730 }
731
732 pub fn import_session(&self, data: &str) -> Result<(), MemoryError> {
734 let threads: HashMap<ThreadId, SerializedThread> = serde_json::from_str(data)
735 .map_err(|e| MemoryError(format!("failed to deserialize session: {e}")))?;
736 for (tid, st) in threads {
737 self.restore_thread_meta(&tid, st.metadata);
738 self.core.set_thread_messages(&tid, st.snapshot.messages);
739 self.core
740 .set_thread_compaction_summaries(&tid, st.snapshot.compaction_summaries);
741 if !st.views.is_empty() {
742 self.views
743 .lock()
744 .expect("bug: mutex poisoned")
745 .insert(tid.clone(), st.views);
746 }
747 self.loaded
748 .lock()
749 .expect("bug: mutex poisoned")
750 .insert(tid.clone());
751 self.metadata_loaded
752 .lock()
753 .expect("bug: mutex poisoned")
754 .insert(tid.clone());
755 self.save_thread(&tid);
756 self.save_views(&tid);
757 }
758 Ok(())
759 }
760}
761
762#[async_trait]
763impl ConversationStore for PersistentConversationStore {
764 type Error = MemoryError;
765
766 async fn ensure_root_thread(&self, thread_id: &ThreadId<str>) -> Result<(), MemoryError> {
767 self.ensure_thread_loaded(thread_id);
768 let inserted = self.core.thread_info(thread_id).is_none();
769 if inserted {
770 self.core.ensure_root_thread(thread_id).await?;
771 self.extras.lock().expect("bug: mutex poisoned").insert(
772 thread_id.to_owned(),
773 ThreadExtras::new(self.default_model.clone()),
774 );
775 self.save_thread(thread_id);
776 }
777 Ok(())
778 }
779
780 async fn thread_exists(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
781 Ok(self.has_thread(thread_id))
782 }
783
784 async fn load_history_up_to(
785 &self,
786 session_id: &ThreadId<str>,
787 start_from: Option<i64>,
788 up_to: Option<i64>,
789 ) -> Result<Vec<InfinityMessage>, MemoryError> {
790 self.ensure_thread_loaded(session_id);
791 Ok(self
792 .core
793 .load_history_up_to(session_id, start_from, up_to)
794 .await?)
795 }
796
797 async fn append_messages(
798 &self,
799 session_id: &ThreadId<str>,
800 messages: Vec<(InfinityMessage, String)>,
801 ) -> Result<(), MemoryError> {
802 self.ensure_thread_loaded(session_id);
803 tracing::trace!("Appending messages to store");
804 self.core.append_messages(session_id, messages).await?;
805 self.save_thread(session_id);
806 Ok(())
807 }
808
809 async fn spawn_thread(
810 &self,
811 parent_thread_id: &ThreadId<str>,
812 spawn_tool_call_id: &rap_protocol::ToolCallId<str>,
813 is_for_subscription_event: bool,
814 context: SpawnContext,
815 ) -> Result<ThreadId, MemoryError> {
816 self.ensure_thread_loaded(parent_thread_id);
817 let new_id = self.id_source.generate();
818 {
819 let mut loaded = self.loaded.lock().expect("bug: mutex poisoned");
822 let mut meta_loaded = self.metadata_loaded.lock().expect("bug: mutex poisoned");
823
824 self.core.spawn_thread_with_id(
827 &new_id,
828 parent_thread_id,
829 spawn_tool_call_id,
830 is_for_subscription_event,
831 context,
832 );
833 self.core.set_thread_messages(&new_id, Vec::new());
834
835 {
836 let mut extras = self.extras.lock().expect("bug: mutex poisoned");
837 let parent_model = extras
839 .get(parent_thread_id)
840 .map(|e| e.selected_model.clone())
841 .unwrap_or_else(|| self.default_model.clone());
842 extras.insert(new_id.clone(), ThreadExtras::new(parent_model));
843 if let Some(parent) = extras.get_mut(parent_thread_id) {
844 parent.children.push(new_id.clone());
845 }
846 }
847
848 loaded.insert(new_id.clone());
849 meta_loaded.insert(new_id.clone());
850 }
851
852 self.save_thread(&new_id);
853 self.save_thread_metadata(parent_thread_id);
854 self.notify_session(parent_thread_id);
855 Ok(new_id)
856 }
857
858 async fn is_thread_closed(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
859 self.ensure_thread_metadata_loaded(thread_id);
860 Ok(self.core.is_thread_closed(thread_id).await?)
861 }
862
863 async fn close_thread(&self, thread_id: &ThreadId<str>) -> Result<(), MemoryError> {
864 self.ensure_thread_metadata_loaded(thread_id);
865 self.core.close_thread(thread_id).await?;
866 self.save_thread_metadata(thread_id);
867 self.notify_session(thread_id);
868 Ok(())
869 }
870
871 async fn is_subscription_event_thread(
872 &self,
873 thread_id: &ThreadId<str>,
874 ) -> Result<bool, MemoryError> {
875 self.ensure_thread_metadata_loaded(thread_id);
876 Ok(self.core.is_subscription_event_thread(thread_id).await?)
877 }
878
879 async fn is_fresh_context_thread(
880 &self,
881 thread_id: &ThreadId<str>,
882 ) -> Result<bool, MemoryError> {
883 self.ensure_thread_metadata_loaded(thread_id);
884 Ok(self.core.is_fresh_context_thread(thread_id).await?)
885 }
886
887 async fn get_thread_parent_info(
888 &self,
889 thread_id: &ThreadId<str>,
890 ) -> Result<Option<(ThreadId, rap_protocol::ToolCallId)>, MemoryError> {
891 self.ensure_thread_metadata_loaded(thread_id);
892 Ok(self.core.get_thread_parent_info(thread_id).await?)
893 }
894
895 async fn get_ancestor_chain(
896 &self,
897 thread_id: &ThreadId<str>,
898 ) -> Result<Vec<(ThreadId, i64)>, MemoryError> {
899 let mut current = thread_id.to_owned();
902 loop {
903 self.ensure_thread_metadata_loaded(¤t);
904 match self
905 .core
906 .thread_info(¤t)
907 .and_then(|t| t.parent_thread_id)
908 {
909 Some(parent) => current = parent,
910 None => break,
911 }
912 }
913 Ok(self.core.get_ancestor_chain(thread_id).await?)
914 }
915
916 async fn save_compaction_summary(
917 &self,
918 thread_id: &ThreadId<str>,
919 summary: &str,
920 up_to_order: i64,
921 ) -> Result<(), MemoryError> {
922 self.ensure_thread_loaded(thread_id);
923 self.core
924 .save_compaction_summary(thread_id, summary, up_to_order)
925 .await?;
926 self.save_thread(thread_id);
927 Ok(())
928 }
929
930 async fn load_latest_compaction_summary_up_to(
931 &self,
932 thread_id: &ThreadId<str>,
933 up_to_order: Option<i64>,
934 ) -> Result<Option<(String, i64)>, MemoryError> {
935 self.ensure_thread_loaded(thread_id);
936 Ok(self
937 .core
938 .load_latest_compaction_summary_up_to(thread_id, up_to_order)
939 .await?)
940 }
941
942 async fn is_compaction_thread(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
943 self.ensure_thread_metadata_loaded(thread_id);
944 Ok(self.core.is_compaction_thread(thread_id).await?)
945 }
946
947 async fn mark_thread_as_compaction(
948 &self,
949 thread_id: &ThreadId<str>,
950 ) -> Result<(), MemoryError> {
951 self.ensure_thread_metadata_loaded(thread_id);
952 self.core.mark_thread_as_compaction(thread_id).await?;
953 self.save_thread_metadata(thread_id);
954 Ok(())
955 }
956
957 async fn get_thread_spawn_order(
958 &self,
959 thread_id: &ThreadId<str>,
960 ) -> Result<Option<i64>, MemoryError> {
961 self.ensure_thread_metadata_loaded(thread_id);
962 Ok(self.core.get_thread_spawn_order(thread_id).await?)
963 }
964}
965
966#[derive(Clone)]
969pub struct PersistentStateStore {
970 core: core_stores::InMemoryStateStore,
972 dir: PathBuf,
974 loaded: Arc<Mutex<HashSet<ThreadId>>>,
976 conversation_store: PersistentConversationStore,
978 session_store: Arc<tokio::sync::Mutex<crate::session_store::SessionStore>>,
979}
980
981impl PersistentStateStore {
982 pub fn new(
983 dir: impl AsRef<Path>,
984 conversation_store: PersistentConversationStore,
985 session_store: Arc<tokio::sync::Mutex<crate::session_store::SessionStore>>,
986 ) -> Self {
987 let dir = dir.as_ref().to_path_buf();
988 std::fs::create_dir_all(&dir).ok();
989 Self {
990 core: core_stores::InMemoryStateStore::new(),
991 dir,
992 loaded: Arc::new(Mutex::new(HashSet::new())),
993 conversation_store,
994 session_store,
995 }
996 }
997
998 pub fn has_pending_choices(&self, thread_id: &ThreadId<str>) -> bool {
999 self.ensure_loaded(thread_id);
1000 !self
1001 .core
1002 .thread_state(thread_id)
1003 .pending_user_choices
1004 .is_empty()
1005 }
1006
1007 pub fn has_pending_choices_for_session(&self, session_id: &ThreadId<str>) -> bool {
1011 self.conversation_store
1012 .get_session_thread_ids(session_id)
1013 .iter()
1014 .any(|thread_id| self.has_pending_choices(thread_id))
1015 }
1016
1017 pub fn pending_choice(
1018 &self,
1019 thread_id: &ThreadId<str>,
1020 choice_id: &rap_protocol::ChoiceId<str>,
1021 ) -> Option<UserChoice> {
1022 self.ensure_loaded(thread_id);
1023 self.core
1024 .thread_state(thread_id)
1025 .pending_user_choices
1026 .into_iter()
1027 .find(|choice| choice.id == *choice_id)
1028 }
1029
1030 pub async fn clear_pending_choices(
1031 &self,
1032 thread_id: &ThreadId<str>,
1033 ) -> Result<(), MemoryError> {
1034 let choices = self.get_pending_user_choices(thread_id).await?;
1035 for choice in choices {
1036 self.remove_pending_user_choice(thread_id, &choice.id)
1037 .await?;
1038 }
1039 Ok(())
1040 }
1041
1042 pub async fn clear_pending_choices_for_session(
1045 &self,
1046 session_id: &ThreadId<str>,
1047 ) -> Result<(), MemoryError> {
1048 for thread_id in self.conversation_store.get_session_thread_ids(session_id) {
1049 self.clear_pending_choices(&thread_id).await?;
1050 }
1051 Ok(())
1052 }
1053
1054 fn save_key(&self, key: &ThreadId<str>) {
1057 let snapshot = self.core.thread_state(key);
1058 let path = self.dir.join(format!("{}.state.json", key));
1059 if let Ok(json) = serde_json::to_string_pretty(&snapshot) {
1060 std::fs::write(path, json).ok();
1061 }
1062 }
1063
1064 fn ensure_loaded(&self, key: &ThreadId<str>) {
1066 let mut loaded = self.loaded.lock().expect("bug: mutex poisoned");
1067 if loaded.contains(key) {
1068 return;
1069 }
1070
1071 let path = self.dir.join(format!("{}.state.json", key));
1072 if let Ok(json) = std::fs::read_to_string(&path)
1073 && let Ok(snapshot) = serde_json::from_str::<ThreadState>(&json)
1074 {
1075 self.core.set_thread_state(key, snapshot);
1076 }
1077
1078 loaded.insert(key.to_owned());
1079 }
1080}
1081
1082#[async_trait]
1083impl StateStore for PersistentStateStore {
1084 type Error = MemoryError;
1085
1086 async fn get_processed_ids(
1087 &self,
1088 thread_id: &ThreadId<str>,
1089 ) -> Result<HashSet<String>, MemoryError> {
1090 self.ensure_loaded(thread_id);
1091 Ok(self.core.get_processed_ids(thread_id).await?)
1092 }
1093
1094 async fn add_processed_message_ids(
1095 &self,
1096 thread_id: &ThreadId<str>,
1097 message_ids: Vec<String>,
1098 ) -> Result<(), MemoryError> {
1099 self.ensure_loaded(thread_id);
1100 self.core
1101 .add_processed_message_ids(thread_id, message_ids)
1102 .await?;
1103 self.save_key(thread_id);
1104 Ok(())
1105 }
1106
1107 async fn get_metadata(
1108 &self,
1109 root_thread_id: &ThreadId<str>,
1110 ) -> Result<Option<serde_json::Value>, MemoryError> {
1111 self.ensure_loaded(root_thread_id);
1112 Ok(self.core.get_metadata(root_thread_id).await?)
1113 }
1114
1115 async fn set_metadata(
1116 &self,
1117 root_thread_id: &ThreadId<str>,
1118 metadata: serde_json::Value,
1119 ) -> Result<(), MemoryError> {
1120 self.ensure_loaded(root_thread_id);
1121 self.core.set_metadata(root_thread_id, metadata).await?;
1122 self.save_key(root_thread_id);
1123 Ok(())
1124 }
1125
1126 async fn get_active_subscriptions(
1127 &self,
1128 thread_id: &ThreadId<str>,
1129 ) -> Result<Vec<rap_protocol::ToolCallId>, MemoryError> {
1130 self.ensure_loaded(thread_id);
1131 Ok(self.core.get_active_subscriptions(thread_id).await?)
1132 }
1133
1134 async fn add_active_subscription(
1135 &self,
1136 thread_id: &ThreadId<str>,
1137 tool_call_id: &rap_protocol::ToolCallId<str>,
1138 ) -> Result<(), MemoryError> {
1139 self.ensure_loaded(thread_id);
1140 self.core
1141 .add_active_subscription(thread_id, tool_call_id)
1142 .await?;
1143 self.save_key(thread_id);
1144 Ok(())
1145 }
1146
1147 async fn remove_active_subscription(
1148 &self,
1149 thread_id: &ThreadId<str>,
1150 tool_call_id: &rap_protocol::ToolCallId<str>,
1151 ) -> Result<(), MemoryError> {
1152 self.ensure_loaded(thread_id);
1153 self.core
1154 .remove_active_subscription(thread_id, tool_call_id)
1155 .await?;
1156 self.save_key(thread_id);
1157 Ok(())
1158 }
1159
1160 async fn add_pending_user_choice(
1161 &self,
1162 thread_id: &ThreadId<str>,
1163 choice: UserChoice,
1164 ) -> Result<(), MemoryError> {
1165 self.ensure_loaded(thread_id);
1166 self.core.add_pending_user_choice(thread_id, choice).await?;
1167 self.save_key(thread_id);
1168 self.conversation_store.notify_session(thread_id);
1169 Ok(())
1170 }
1171
1172 async fn remove_pending_user_choice(
1173 &self,
1174 thread_id: &ThreadId<str>,
1175 choice_id: &rap_protocol::ChoiceId<str>,
1176 ) -> Result<(), MemoryError> {
1177 self.ensure_loaded(thread_id);
1178 self.core
1179 .remove_pending_user_choice(thread_id, choice_id)
1180 .await?;
1181 self.save_key(thread_id);
1182 self.conversation_store.notify_session(thread_id);
1183 Ok(())
1184 }
1185
1186 async fn get_pending_user_choices(
1187 &self,
1188 thread_id: &ThreadId<str>,
1189 ) -> Result<Vec<UserChoice>, MemoryError> {
1190 self.ensure_loaded(thread_id);
1191 Ok(self.core.get_pending_user_choices(thread_id).await?)
1192 }
1193
1194 async fn is_thread_stopped(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
1195 let session_id = self.conversation_store.get_root_thread_id(thread_id);
1196 Ok(self.session_store.lock().await.is_shut_down(&session_id))
1197 }
1198}
1199
1200#[cfg(test)]
1201mod tests {
1202 use super::*;
1203 use infinity_agent_core::traits::ConversationStore;
1204 use infinity_provider_protocol::message::{AssistantContent, Message, UserContent};
1205
1206 fn test_model() -> ModelRef {
1207 ModelRef {
1208 provider_id: "test".to_owned(),
1209 model_id: "test-model".to_owned(),
1210 }
1211 }
1212
1213 fn user_msg(text: &str) -> InfinityMessage {
1214 InfinityMessage::from_message(Message::User {
1215 content: vec![UserContent::text(text)],
1216 })
1217 }
1218
1219 #[test]
1223 fn thread_meta_format_is_flat_and_backward_compatible() {
1224 let old_json = serde_json::json!({
1225 "parent_thread_id": "p",
1226 "root_thread_id": "r",
1227 "spawn_message_order": 3,
1228 "spawn_tool_call_id": "tc",
1229 "closed": false,
1230 "is_subscription_event": false,
1231 "title": "t",
1232 "is_compaction": false,
1233 "children": ["c1"],
1234 "total_tokens_used": 42,
1235 "last_updated": "2024",
1236 "selected_model": {"provider_id": "prov", "model_id": "m"}
1237 });
1238 let meta: ThreadMeta =
1239 serde_json::from_value(old_json.clone()).expect("old flat format parses");
1240 assert_eq!(meta.info.root_thread_id.as_str(), "r");
1241 assert_eq!(meta.info.spawn_message_order, Some(3));
1242 assert!(!meta.info.fresh_context, "missing fresh_context defaults");
1243 assert_eq!(meta.extras.total_tokens_used, 42);
1244 assert_eq!(meta.extras.selected_model.provider_id, "prov");
1245 let round = serde_json::to_value(&meta).expect("serialize ThreadMeta");
1246 let mut expected = old_json;
1249 expected["fresh_context"] = serde_json::json!(false);
1250 assert_eq!(
1251 round, expected,
1252 "flattened ThreadMeta must keep the flat on-disk format"
1253 );
1254 }
1255 fn asst_msg(text: &str) -> InfinityMessage {
1256 InfinityMessage::from_message(Message::Assistant {
1257 content: vec![AssistantContent::text(text)],
1258 })
1259 }
1260
1261 #[tokio::test]
1264 async fn ancestors_basic_cutoff() {
1265 let dir = tempfile::tempdir().expect("create temp dir");
1266 let store = PersistentConversationStore::new_with_dir(
1267 dir.path(),
1268 test_model(),
1269 Arc::new(crate::ids::UuidIdSource),
1270 );
1271 store
1272 .ensure_root_thread(ThreadId::from_ref("root"))
1273 .await
1274 .expect("ensure root thread");
1275 store
1276 .append_messages(
1277 ThreadId::from_ref("root"),
1278 vec![(user_msg("p1"), "m1".into()), (asst_msg("p2"), "m2".into())],
1279 )
1280 .await
1281 .expect("append root messages");
1282
1283 let child = store
1284 .spawn_thread(
1285 ThreadId::from_ref("root"),
1286 rap_protocol::ToolCallId::from_ref("tc-1"),
1287 false,
1288 SpawnContext::InheritUpTo(2),
1289 )
1290 .await
1291 .expect("spawn child thread");
1292
1293 store
1294 .append_messages(
1295 ThreadId::from_ref("root"),
1296 vec![(user_msg("p3"), "m3".into()), (asst_msg("p4"), "m4".into())],
1297 )
1298 .await
1299 .expect("append root messages after spawn");
1300
1301 store
1302 .append_messages(&child, vec![(user_msg("c1"), "m5".into())])
1303 .await
1304 .expect("append child messages");
1305
1306 let (history, _, _) = store
1307 .load_history_with_ancestors(&child)
1308 .await
1309 .expect("load history with ancestors");
1310 assert_eq!(history.len(), 3);
1311 if let InfinityMessage::User {
1312 content: UserContent::Text(t),
1313 } = &history[0]
1314 {
1315 assert_eq!(t.text, "p1");
1316 }
1317 if let InfinityMessage::User {
1318 content: UserContent::Text(t),
1319 } = &history[2]
1320 {
1321 assert_eq!(t.text, "c1");
1322 }
1323 }
1324
1325 #[tokio::test]
1327 async fn ancestors_three_levels() {
1328 let dir = tempfile::tempdir().expect("create temp dir");
1329 let store = PersistentConversationStore::new_with_dir(
1330 dir.path(),
1331 test_model(),
1332 Arc::new(crate::ids::UuidIdSource),
1333 );
1334 store
1335 .ensure_root_thread(ThreadId::from_ref("root"))
1336 .await
1337 .expect("ensure root thread");
1338 store
1339 .append_messages(
1340 ThreadId::from_ref("root"),
1341 vec![(user_msg("r1"), "m1".into())],
1342 )
1343 .await
1344 .expect("append root messages");
1345
1346 let child = store
1347 .spawn_thread(
1348 ThreadId::from_ref("root"),
1349 rap_protocol::ToolCallId::from_ref("tc-1"),
1350 false,
1351 SpawnContext::InheritUpTo(1),
1352 )
1353 .await
1354 .expect("spawn child thread");
1355 store
1356 .append_messages(
1357 &child,
1358 vec![(user_msg("c1"), "m2".into()), (asst_msg("c2"), "m3".into())],
1359 )
1360 .await
1361 .expect("append child messages");
1362
1363 let grandchild = store
1364 .spawn_thread(
1365 &child,
1366 rap_protocol::ToolCallId::from_ref("tc-2"),
1367 false,
1368 SpawnContext::InheritUpTo(2),
1369 )
1370 .await
1371 .expect("spawn grandchild thread");
1372 store
1373 .append_messages(&grandchild, vec![(user_msg("g1"), "m4".into())])
1374 .await
1375 .expect("append grandchild messages");
1376
1377 let (history, _, _) = store
1378 .load_history_with_ancestors(&grandchild)
1379 .await
1380 .expect("load history with ancestors");
1381 assert_eq!(history.len(), 4);
1382 }
1383
1384 #[tokio::test]
1386 async fn ancestors_with_compaction_on_self() {
1387 let dir = tempfile::tempdir().expect("create temp dir");
1388 let store = PersistentConversationStore::new_with_dir(
1389 dir.path(),
1390 test_model(),
1391 Arc::new(crate::ids::UuidIdSource),
1392 );
1393 store
1394 .ensure_root_thread(ThreadId::from_ref("root"))
1395 .await
1396 .expect("ensure root thread");
1397 store
1398 .append_messages(
1399 ThreadId::from_ref("root"),
1400 vec![
1401 (user_msg("old1"), "m1".into()),
1402 (asst_msg("old2"), "m2".into()),
1403 (user_msg("new1"), "m3".into()),
1404 (asst_msg("new2"), "m4".into()),
1405 ],
1406 )
1407 .await
1408 .expect("append root messages");
1409
1410 store
1411 .save_compaction_summary(ThreadId::from_ref("root"), "summary of old stuff", 2)
1412 .await
1413 .expect("save compaction summary");
1414
1415 let (history, compacted_up_to, _) = store
1416 .load_history_with_ancestors(ThreadId::from_ref("root"))
1417 .await
1418 .expect("load history with ancestors");
1419 assert_eq!(history.len(), 3);
1420 assert_eq!(compacted_up_to, Some(2));
1421 if let InfinityMessage::Assistant {
1422 content: AssistantContent::Text(t),
1423 } = &history[0]
1424 {
1425 assert!(t.text.contains("summary of old stuff"));
1426 }
1427 }
1428
1429 #[tokio::test]
1431 async fn ancestors_with_compaction_on_parent() {
1432 let dir = tempfile::tempdir().expect("create temp dir");
1433 let store = PersistentConversationStore::new_with_dir(
1434 dir.path(),
1435 test_model(),
1436 Arc::new(crate::ids::UuidIdSource),
1437 );
1438 store
1439 .ensure_root_thread(ThreadId::from_ref("root"))
1440 .await
1441 .expect("ensure root thread");
1442 store
1443 .append_messages(
1444 ThreadId::from_ref("root"),
1445 vec![
1446 (user_msg("old1"), "m1".into()),
1447 (asst_msg("old2"), "m2".into()),
1448 (user_msg("recent"), "m3".into()),
1449 ],
1450 )
1451 .await
1452 .expect("append root messages");
1453
1454 store
1455 .save_compaction_summary(ThreadId::from_ref("root"), "compacted root", 2)
1456 .await
1457 .expect("save compaction summary");
1458
1459 let child = store
1460 .spawn_thread(
1461 ThreadId::from_ref("root"),
1462 rap_protocol::ToolCallId::from_ref("tc-1"),
1463 false,
1464 SpawnContext::InheritUpTo(3),
1465 )
1466 .await
1467 .expect("spawn child thread");
1468 store
1469 .append_messages(&child, vec![(user_msg("c1"), "m4".into())])
1470 .await
1471 .expect("append child messages");
1472
1473 let (history, _, _) = store
1474 .load_history_with_ancestors(&child)
1475 .await
1476 .expect("load history with ancestors");
1477 assert_eq!(history.len(), 3);
1478 if let InfinityMessage::Assistant {
1479 content: AssistantContent::Text(t),
1480 } = &history[0]
1481 {
1482 assert!(t.text.contains("compacted root"));
1483 }
1484 }
1485
1486 #[tokio::test]
1488 async fn ancestors_multiple_compactions_picks_latest() {
1489 let dir = tempfile::tempdir().expect("create temp dir");
1490 let store = PersistentConversationStore::new_with_dir(
1491 dir.path(),
1492 test_model(),
1493 Arc::new(crate::ids::UuidIdSource),
1494 );
1495 store
1496 .ensure_root_thread(ThreadId::from_ref("root"))
1497 .await
1498 .expect("ensure root thread");
1499 store
1500 .append_messages(
1501 ThreadId::from_ref("root"),
1502 vec![
1503 (user_msg("a"), "m1".into()),
1504 (asst_msg("b"), "m2".into()),
1505 (user_msg("c"), "m3".into()),
1506 (asst_msg("d"), "m4".into()),
1507 (user_msg("e"), "m5".into()),
1508 ],
1509 )
1510 .await
1511 .expect("append root messages");
1512
1513 store
1514 .save_compaction_summary(ThreadId::from_ref("root"), "early summary", 2)
1515 .await
1516 .expect("save early compaction summary");
1517 store
1518 .save_compaction_summary(ThreadId::from_ref("root"), "later summary", 4)
1519 .await
1520 .expect("save later compaction summary");
1521
1522 let child = store
1523 .spawn_thread(
1524 ThreadId::from_ref("root"),
1525 rap_protocol::ToolCallId::from_ref("tc-1"),
1526 false,
1527 SpawnContext::InheritUpTo(5),
1528 )
1529 .await
1530 .expect("spawn child thread");
1531 store
1532 .append_messages(&child, vec![(user_msg("c1"), "m6".into())])
1533 .await
1534 .expect("append child messages");
1535
1536 let (history, _, _) = store
1537 .load_history_with_ancestors(&child)
1538 .await
1539 .expect("load history with ancestors");
1540 assert_eq!(history.len(), 3);
1541 if let InfinityMessage::Assistant {
1542 content: AssistantContent::Text(t),
1543 } = &history[0]
1544 {
1545 assert!(t.text.contains("later summary"));
1546 }
1547 }
1548
1549 #[tokio::test]
1552 async fn leaf_compaction_takes_priority_over_ancestor() {
1553 let dir = tempfile::tempdir().expect("create temp dir");
1554 let store = PersistentConversationStore::new_with_dir(
1555 dir.path(),
1556 test_model(),
1557 Arc::new(crate::ids::UuidIdSource),
1558 );
1559 store
1560 .ensure_root_thread(ThreadId::from_ref("root"))
1561 .await
1562 .expect("ensure root thread");
1563 store
1564 .append_messages(
1565 ThreadId::from_ref("root"),
1566 vec![(user_msg("r1"), "m1".into()), (asst_msg("r2"), "m2".into())],
1567 )
1568 .await
1569 .expect("append root messages");
1570 store
1571 .save_compaction_summary(ThreadId::from_ref("root"), "root compaction", 2)
1572 .await
1573 .expect("save root compaction summary");
1574
1575 let child = store
1576 .spawn_thread(
1577 ThreadId::from_ref("root"),
1578 rap_protocol::ToolCallId::from_ref("tc-1"),
1579 false,
1580 SpawnContext::InheritUpTo(2),
1581 )
1582 .await
1583 .expect("spawn child thread");
1584 store
1585 .append_messages(
1586 &child,
1587 vec![
1588 (user_msg("c1"), "m3".into()),
1589 (asst_msg("c2"), "m4".into()),
1590 (user_msg("c3"), "m5".into()),
1591 (asst_msg("c4"), "m6".into()),
1592 ],
1593 )
1594 .await
1595 .expect("append child messages");
1596 store
1597 .save_compaction_summary(&child, "child compaction", 2)
1598 .await
1599 .expect("save child compaction summary");
1600
1601 let (history, compacted_up_to, _) = store
1602 .load_history_with_ancestors(&child)
1603 .await
1604 .expect("load history with ancestors");
1605 assert_eq!(history.len(), 3);
1608 assert_eq!(compacted_up_to, Some(2));
1609 if let InfinityMessage::Assistant {
1610 content: AssistantContent::Text(t),
1611 } = &history[0]
1612 {
1613 assert!(
1614 t.text.contains("child compaction"),
1615 "should use child's compaction, got: {}",
1616 t.text
1617 );
1618 assert!(
1619 !t.text.contains("root compaction"),
1620 "should NOT contain root compaction"
1621 );
1622 }
1623 if let InfinityMessage::User {
1625 content: UserContent::Text(t),
1626 } = &history[1]
1627 {
1628 assert_eq!(t.text, "c3");
1629 }
1630 }
1631}