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, 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: child_id.to_string(),
569 parent_thread_id: pid.to_string(),
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: &str,
813 is_for_subscription_event: bool,
814 spawn_order_override: Option<usize>,
815 ) -> Result<ThreadId, MemoryError> {
816 self.ensure_thread_loaded(parent_thread_id);
817 let new_id = ThreadId::from(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 spawn_order_override,
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 get_thread_parent_info(
880 &self,
881 thread_id: &ThreadId<str>,
882 ) -> Result<Option<(ThreadId, String)>, MemoryError> {
883 self.ensure_thread_metadata_loaded(thread_id);
884 Ok(self.core.get_thread_parent_info(thread_id).await?)
885 }
886
887 async fn get_ancestor_chain(
888 &self,
889 thread_id: &ThreadId<str>,
890 ) -> Result<Vec<(ThreadId, i64)>, MemoryError> {
891 let mut current = thread_id.to_owned();
894 loop {
895 self.ensure_thread_metadata_loaded(¤t);
896 match self
897 .core
898 .thread_info(¤t)
899 .and_then(|t| t.parent_thread_id)
900 {
901 Some(parent) => current = parent,
902 None => break,
903 }
904 }
905 Ok(self.core.get_ancestor_chain(thread_id).await?)
906 }
907
908 async fn save_compaction_summary(
909 &self,
910 thread_id: &ThreadId<str>,
911 summary: &str,
912 up_to_order: i64,
913 ) -> Result<(), MemoryError> {
914 self.ensure_thread_loaded(thread_id);
915 self.core
916 .save_compaction_summary(thread_id, summary, up_to_order)
917 .await?;
918 self.save_thread(thread_id);
919 Ok(())
920 }
921
922 async fn load_latest_compaction_summary_up_to(
923 &self,
924 thread_id: &ThreadId<str>,
925 up_to_order: Option<i64>,
926 ) -> Result<Option<(String, i64)>, MemoryError> {
927 self.ensure_thread_loaded(thread_id);
928 Ok(self
929 .core
930 .load_latest_compaction_summary_up_to(thread_id, up_to_order)
931 .await?)
932 }
933
934 async fn is_compaction_thread(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
935 self.ensure_thread_metadata_loaded(thread_id);
936 Ok(self.core.is_compaction_thread(thread_id).await?)
937 }
938
939 async fn mark_thread_as_compaction(
940 &self,
941 thread_id: &ThreadId<str>,
942 ) -> Result<(), MemoryError> {
943 self.ensure_thread_metadata_loaded(thread_id);
944 self.core.mark_thread_as_compaction(thread_id).await?;
945 self.save_thread_metadata(thread_id);
946 Ok(())
947 }
948
949 async fn get_thread_spawn_order(
950 &self,
951 thread_id: &ThreadId<str>,
952 ) -> Result<Option<i64>, MemoryError> {
953 self.ensure_thread_metadata_loaded(thread_id);
954 Ok(self.core.get_thread_spawn_order(thread_id).await?)
955 }
956}
957
958#[derive(Clone)]
961pub struct PersistentStateStore {
962 core: core_stores::InMemoryStateStore,
964 dir: PathBuf,
966 loaded: Arc<Mutex<HashSet<ThreadId>>>,
968 conversation_store: PersistentConversationStore,
970 session_store: Arc<tokio::sync::Mutex<crate::session_store::SessionStore>>,
971}
972
973impl PersistentStateStore {
974 pub fn new(
975 dir: impl AsRef<Path>,
976 conversation_store: PersistentConversationStore,
977 session_store: Arc<tokio::sync::Mutex<crate::session_store::SessionStore>>,
978 ) -> Self {
979 let dir = dir.as_ref().to_path_buf();
980 std::fs::create_dir_all(&dir).ok();
981 Self {
982 core: core_stores::InMemoryStateStore::new(),
983 dir,
984 loaded: Arc::new(Mutex::new(HashSet::new())),
985 conversation_store,
986 session_store,
987 }
988 }
989
990 pub fn has_pending_choices(&self, thread_id: &ThreadId<str>) -> bool {
991 self.ensure_loaded(thread_id);
992 !self
993 .core
994 .thread_state(thread_id)
995 .pending_user_choices
996 .is_empty()
997 }
998
999 pub fn has_pending_choices_for_session(&self, session_id: &ThreadId<str>) -> bool {
1003 self.conversation_store
1004 .get_session_thread_ids(session_id)
1005 .iter()
1006 .any(|thread_id| self.has_pending_choices(thread_id))
1007 }
1008
1009 pub fn pending_choice(&self, thread_id: &ThreadId<str>, choice_id: &str) -> Option<UserChoice> {
1010 self.ensure_loaded(thread_id);
1011 self.core
1012 .thread_state(thread_id)
1013 .pending_user_choices
1014 .into_iter()
1015 .find(|choice| choice.id == choice_id)
1016 }
1017
1018 pub async fn clear_pending_choices(
1019 &self,
1020 thread_id: &ThreadId<str>,
1021 ) -> Result<(), MemoryError> {
1022 let choices = self.get_pending_user_choices(thread_id).await?;
1023 for choice in choices {
1024 self.remove_pending_user_choice(thread_id, &choice.id)
1025 .await?;
1026 }
1027 Ok(())
1028 }
1029
1030 pub async fn clear_pending_choices_for_session(
1033 &self,
1034 session_id: &ThreadId<str>,
1035 ) -> Result<(), MemoryError> {
1036 for thread_id in self.conversation_store.get_session_thread_ids(session_id) {
1037 self.clear_pending_choices(&thread_id).await?;
1038 }
1039 Ok(())
1040 }
1041
1042 fn save_key(&self, key: &ThreadId<str>) {
1045 let snapshot = self.core.thread_state(key);
1046 let path = self.dir.join(format!("{}.state.json", key));
1047 if let Ok(json) = serde_json::to_string_pretty(&snapshot) {
1048 std::fs::write(path, json).ok();
1049 }
1050 }
1051
1052 fn ensure_loaded(&self, key: &ThreadId<str>) {
1054 let mut loaded = self.loaded.lock().expect("bug: mutex poisoned");
1055 if loaded.contains(key) {
1056 return;
1057 }
1058
1059 let path = self.dir.join(format!("{}.state.json", key));
1060 if let Ok(json) = std::fs::read_to_string(&path)
1061 && let Ok(snapshot) = serde_json::from_str::<ThreadState>(&json)
1062 {
1063 self.core.set_thread_state(key, snapshot);
1064 }
1065
1066 loaded.insert(key.to_owned());
1067 }
1068}
1069
1070#[async_trait]
1071impl StateStore for PersistentStateStore {
1072 type Error = MemoryError;
1073
1074 async fn get_processed_ids(
1075 &self,
1076 thread_id: &ThreadId<str>,
1077 ) -> Result<HashSet<String>, MemoryError> {
1078 self.ensure_loaded(thread_id);
1079 Ok(self.core.get_processed_ids(thread_id).await?)
1080 }
1081
1082 async fn add_processed_message_ids(
1083 &self,
1084 thread_id: &ThreadId<str>,
1085 message_ids: Vec<String>,
1086 ) -> Result<(), MemoryError> {
1087 self.ensure_loaded(thread_id);
1088 self.core
1089 .add_processed_message_ids(thread_id, message_ids)
1090 .await?;
1091 self.save_key(thread_id);
1092 Ok(())
1093 }
1094
1095 async fn get_metadata(
1096 &self,
1097 root_thread_id: &ThreadId<str>,
1098 ) -> Result<Option<serde_json::Value>, MemoryError> {
1099 self.ensure_loaded(root_thread_id);
1100 Ok(self.core.get_metadata(root_thread_id).await?)
1101 }
1102
1103 async fn set_metadata(
1104 &self,
1105 root_thread_id: &ThreadId<str>,
1106 metadata: serde_json::Value,
1107 ) -> Result<(), MemoryError> {
1108 self.ensure_loaded(root_thread_id);
1109 self.core.set_metadata(root_thread_id, metadata).await?;
1110 self.save_key(root_thread_id);
1111 Ok(())
1112 }
1113
1114 async fn get_active_subscriptions(
1115 &self,
1116 thread_id: &ThreadId<str>,
1117 ) -> Result<Vec<String>, MemoryError> {
1118 self.ensure_loaded(thread_id);
1119 Ok(self.core.get_active_subscriptions(thread_id).await?)
1120 }
1121
1122 async fn add_active_subscription(
1123 &self,
1124 thread_id: &ThreadId<str>,
1125 tool_call_id: &str,
1126 ) -> Result<(), MemoryError> {
1127 self.ensure_loaded(thread_id);
1128 self.core
1129 .add_active_subscription(thread_id, tool_call_id)
1130 .await?;
1131 self.save_key(thread_id);
1132 Ok(())
1133 }
1134
1135 async fn remove_active_subscription(
1136 &self,
1137 thread_id: &ThreadId<str>,
1138 tool_call_id: &str,
1139 ) -> Result<(), MemoryError> {
1140 self.ensure_loaded(thread_id);
1141 self.core
1142 .remove_active_subscription(thread_id, tool_call_id)
1143 .await?;
1144 self.save_key(thread_id);
1145 Ok(())
1146 }
1147
1148 async fn add_pending_user_choice(
1149 &self,
1150 thread_id: &ThreadId<str>,
1151 choice: UserChoice,
1152 ) -> Result<(), MemoryError> {
1153 self.ensure_loaded(thread_id);
1154 self.core.add_pending_user_choice(thread_id, choice).await?;
1155 self.save_key(thread_id);
1156 self.conversation_store.notify_session(thread_id);
1157 Ok(())
1158 }
1159
1160 async fn remove_pending_user_choice(
1161 &self,
1162 thread_id: &ThreadId<str>,
1163 choice_id: &str,
1164 ) -> Result<(), MemoryError> {
1165 self.ensure_loaded(thread_id);
1166 self.core
1167 .remove_pending_user_choice(thread_id, choice_id)
1168 .await?;
1169 self.save_key(thread_id);
1170 self.conversation_store.notify_session(thread_id);
1171 Ok(())
1172 }
1173
1174 async fn get_pending_user_choices(
1175 &self,
1176 thread_id: &ThreadId<str>,
1177 ) -> Result<Vec<UserChoice>, MemoryError> {
1178 self.ensure_loaded(thread_id);
1179 Ok(self.core.get_pending_user_choices(thread_id).await?)
1180 }
1181
1182 async fn is_thread_stopped(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
1183 let session_id = self.conversation_store.get_root_thread_id(thread_id);
1184 Ok(self.session_store.lock().await.is_shut_down(&session_id))
1185 }
1186}
1187
1188#[cfg(test)]
1189mod tests {
1190 use super::*;
1191 use infinity_agent_core::traits::ConversationStore;
1192 use infinity_provider_protocol::message::{AssistantContent, Message, UserContent};
1193
1194 fn test_model() -> ModelRef {
1195 ModelRef {
1196 provider_id: "test".to_owned(),
1197 model_id: "test-model".to_owned(),
1198 }
1199 }
1200
1201 fn user_msg(text: &str) -> InfinityMessage {
1202 InfinityMessage::from_message(Message::User {
1203 content: vec![UserContent::text(text)],
1204 })
1205 }
1206
1207 #[test]
1211 fn thread_meta_format_is_flat_and_backward_compatible() {
1212 let old_json = serde_json::json!({
1213 "parent_thread_id": "p",
1214 "root_thread_id": "r",
1215 "spawn_message_order": 3,
1216 "spawn_tool_call_id": "tc",
1217 "closed": false,
1218 "is_subscription_event": false,
1219 "title": "t",
1220 "is_compaction": false,
1221 "children": ["c1"],
1222 "total_tokens_used": 42,
1223 "last_updated": "2024",
1224 "selected_model": {"provider_id": "prov", "model_id": "m"}
1225 });
1226 let meta: ThreadMeta =
1227 serde_json::from_value(old_json.clone()).expect("old flat format parses");
1228 assert_eq!(meta.info.root_thread_id.as_str(), "r");
1229 assert_eq!(meta.info.spawn_message_order, Some(3));
1230 assert_eq!(meta.extras.total_tokens_used, 42);
1231 assert_eq!(meta.extras.selected_model.provider_id, "prov");
1232 let round = serde_json::to_value(&meta).expect("serialize ThreadMeta");
1233 assert_eq!(
1234 round, old_json,
1235 "flattened ThreadMeta must keep the flat on-disk format"
1236 );
1237 }
1238 fn asst_msg(text: &str) -> InfinityMessage {
1239 InfinityMessage::from_message(Message::Assistant {
1240 content: vec![AssistantContent::text(text)],
1241 })
1242 }
1243
1244 #[tokio::test]
1247 async fn ancestors_basic_cutoff() {
1248 let dir = tempfile::tempdir().expect("create temp dir");
1249 let store = PersistentConversationStore::new_with_dir(
1250 dir.path(),
1251 test_model(),
1252 Arc::new(crate::ids::UuidIdSource),
1253 );
1254 store
1255 .ensure_root_thread(ThreadId::from_ref("root"))
1256 .await
1257 .expect("ensure root thread");
1258 store
1259 .append_messages(
1260 ThreadId::from_ref("root"),
1261 vec![(user_msg("p1"), "m1".into()), (asst_msg("p2"), "m2".into())],
1262 )
1263 .await
1264 .expect("append root messages");
1265
1266 let child = store
1267 .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1268 .await
1269 .expect("spawn child thread");
1270
1271 store
1272 .append_messages(
1273 ThreadId::from_ref("root"),
1274 vec![(user_msg("p3"), "m3".into()), (asst_msg("p4"), "m4".into())],
1275 )
1276 .await
1277 .expect("append root messages after spawn");
1278
1279 store
1280 .append_messages(&child, vec![(user_msg("c1"), "m5".into())])
1281 .await
1282 .expect("append child messages");
1283
1284 let (history, _, _) = store
1285 .load_history_with_ancestors(&child)
1286 .await
1287 .expect("load history with ancestors");
1288 assert_eq!(history.len(), 3);
1289 if let InfinityMessage::User {
1290 content: UserContent::Text(t),
1291 } = &history[0]
1292 {
1293 assert_eq!(t.text, "p1");
1294 }
1295 if let InfinityMessage::User {
1296 content: UserContent::Text(t),
1297 } = &history[2]
1298 {
1299 assert_eq!(t.text, "c1");
1300 }
1301 }
1302
1303 #[tokio::test]
1305 async fn ancestors_three_levels() {
1306 let dir = tempfile::tempdir().expect("create temp dir");
1307 let store = PersistentConversationStore::new_with_dir(
1308 dir.path(),
1309 test_model(),
1310 Arc::new(crate::ids::UuidIdSource),
1311 );
1312 store
1313 .ensure_root_thread(ThreadId::from_ref("root"))
1314 .await
1315 .expect("ensure root thread");
1316 store
1317 .append_messages(
1318 ThreadId::from_ref("root"),
1319 vec![(user_msg("r1"), "m1".into())],
1320 )
1321 .await
1322 .expect("append root messages");
1323
1324 let child = store
1325 .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1326 .await
1327 .expect("spawn child thread");
1328 store
1329 .append_messages(
1330 &child,
1331 vec![(user_msg("c1"), "m2".into()), (asst_msg("c2"), "m3".into())],
1332 )
1333 .await
1334 .expect("append child messages");
1335
1336 let grandchild = store
1337 .spawn_thread(&child, "tc-2", false, None)
1338 .await
1339 .expect("spawn grandchild thread");
1340 store
1341 .append_messages(&grandchild, vec![(user_msg("g1"), "m4".into())])
1342 .await
1343 .expect("append grandchild messages");
1344
1345 let (history, _, _) = store
1346 .load_history_with_ancestors(&grandchild)
1347 .await
1348 .expect("load history with ancestors");
1349 assert_eq!(history.len(), 4);
1350 }
1351
1352 #[tokio::test]
1354 async fn ancestors_with_compaction_on_self() {
1355 let dir = tempfile::tempdir().expect("create temp dir");
1356 let store = PersistentConversationStore::new_with_dir(
1357 dir.path(),
1358 test_model(),
1359 Arc::new(crate::ids::UuidIdSource),
1360 );
1361 store
1362 .ensure_root_thread(ThreadId::from_ref("root"))
1363 .await
1364 .expect("ensure root thread");
1365 store
1366 .append_messages(
1367 ThreadId::from_ref("root"),
1368 vec![
1369 (user_msg("old1"), "m1".into()),
1370 (asst_msg("old2"), "m2".into()),
1371 (user_msg("new1"), "m3".into()),
1372 (asst_msg("new2"), "m4".into()),
1373 ],
1374 )
1375 .await
1376 .expect("append root messages");
1377
1378 store
1379 .save_compaction_summary(ThreadId::from_ref("root"), "summary of old stuff", 2)
1380 .await
1381 .expect("save compaction summary");
1382
1383 let (history, compacted_up_to, _) = store
1384 .load_history_with_ancestors(ThreadId::from_ref("root"))
1385 .await
1386 .expect("load history with ancestors");
1387 assert_eq!(history.len(), 3);
1388 assert_eq!(compacted_up_to, Some(2));
1389 if let InfinityMessage::Assistant {
1390 content: AssistantContent::Text(t),
1391 } = &history[0]
1392 {
1393 assert!(t.text.contains("summary of old stuff"));
1394 }
1395 }
1396
1397 #[tokio::test]
1399 async fn ancestors_with_compaction_on_parent() {
1400 let dir = tempfile::tempdir().expect("create temp dir");
1401 let store = PersistentConversationStore::new_with_dir(
1402 dir.path(),
1403 test_model(),
1404 Arc::new(crate::ids::UuidIdSource),
1405 );
1406 store
1407 .ensure_root_thread(ThreadId::from_ref("root"))
1408 .await
1409 .expect("ensure root thread");
1410 store
1411 .append_messages(
1412 ThreadId::from_ref("root"),
1413 vec![
1414 (user_msg("old1"), "m1".into()),
1415 (asst_msg("old2"), "m2".into()),
1416 (user_msg("recent"), "m3".into()),
1417 ],
1418 )
1419 .await
1420 .expect("append root messages");
1421
1422 store
1423 .save_compaction_summary(ThreadId::from_ref("root"), "compacted root", 2)
1424 .await
1425 .expect("save compaction summary");
1426
1427 let child = store
1428 .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1429 .await
1430 .expect("spawn child thread");
1431 store
1432 .append_messages(&child, vec![(user_msg("c1"), "m4".into())])
1433 .await
1434 .expect("append child messages");
1435
1436 let (history, _, _) = store
1437 .load_history_with_ancestors(&child)
1438 .await
1439 .expect("load history with ancestors");
1440 assert_eq!(history.len(), 3);
1441 if let InfinityMessage::Assistant {
1442 content: AssistantContent::Text(t),
1443 } = &history[0]
1444 {
1445 assert!(t.text.contains("compacted root"));
1446 }
1447 }
1448
1449 #[tokio::test]
1451 async fn ancestors_multiple_compactions_picks_latest() {
1452 let dir = tempfile::tempdir().expect("create temp dir");
1453 let store = PersistentConversationStore::new_with_dir(
1454 dir.path(),
1455 test_model(),
1456 Arc::new(crate::ids::UuidIdSource),
1457 );
1458 store
1459 .ensure_root_thread(ThreadId::from_ref("root"))
1460 .await
1461 .expect("ensure root thread");
1462 store
1463 .append_messages(
1464 ThreadId::from_ref("root"),
1465 vec![
1466 (user_msg("a"), "m1".into()),
1467 (asst_msg("b"), "m2".into()),
1468 (user_msg("c"), "m3".into()),
1469 (asst_msg("d"), "m4".into()),
1470 (user_msg("e"), "m5".into()),
1471 ],
1472 )
1473 .await
1474 .expect("append root messages");
1475
1476 store
1477 .save_compaction_summary(ThreadId::from_ref("root"), "early summary", 2)
1478 .await
1479 .expect("save early compaction summary");
1480 store
1481 .save_compaction_summary(ThreadId::from_ref("root"), "later summary", 4)
1482 .await
1483 .expect("save later compaction summary");
1484
1485 let child = store
1486 .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1487 .await
1488 .expect("spawn child thread");
1489 store
1490 .append_messages(&child, vec![(user_msg("c1"), "m6".into())])
1491 .await
1492 .expect("append child messages");
1493
1494 let (history, _, _) = store
1495 .load_history_with_ancestors(&child)
1496 .await
1497 .expect("load history with ancestors");
1498 assert_eq!(history.len(), 3);
1499 if let InfinityMessage::Assistant {
1500 content: AssistantContent::Text(t),
1501 } = &history[0]
1502 {
1503 assert!(t.text.contains("later summary"));
1504 }
1505 }
1506
1507 #[tokio::test]
1510 async fn leaf_compaction_takes_priority_over_ancestor() {
1511 let dir = tempfile::tempdir().expect("create temp dir");
1512 let store = PersistentConversationStore::new_with_dir(
1513 dir.path(),
1514 test_model(),
1515 Arc::new(crate::ids::UuidIdSource),
1516 );
1517 store
1518 .ensure_root_thread(ThreadId::from_ref("root"))
1519 .await
1520 .expect("ensure root thread");
1521 store
1522 .append_messages(
1523 ThreadId::from_ref("root"),
1524 vec![(user_msg("r1"), "m1".into()), (asst_msg("r2"), "m2".into())],
1525 )
1526 .await
1527 .expect("append root messages");
1528 store
1529 .save_compaction_summary(ThreadId::from_ref("root"), "root compaction", 2)
1530 .await
1531 .expect("save root compaction summary");
1532
1533 let child = store
1534 .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1535 .await
1536 .expect("spawn child thread");
1537 store
1538 .append_messages(
1539 &child,
1540 vec![
1541 (user_msg("c1"), "m3".into()),
1542 (asst_msg("c2"), "m4".into()),
1543 (user_msg("c3"), "m5".into()),
1544 (asst_msg("c4"), "m6".into()),
1545 ],
1546 )
1547 .await
1548 .expect("append child messages");
1549 store
1550 .save_compaction_summary(&child, "child compaction", 2)
1551 .await
1552 .expect("save child compaction summary");
1553
1554 let (history, compacted_up_to, _) = store
1555 .load_history_with_ancestors(&child)
1556 .await
1557 .expect("load history with ancestors");
1558 assert_eq!(history.len(), 3);
1561 assert_eq!(compacted_up_to, Some(2));
1562 if let InfinityMessage::Assistant {
1563 content: AssistantContent::Text(t),
1564 } = &history[0]
1565 {
1566 assert!(
1567 t.text.contains("child compaction"),
1568 "should use child's compaction, got: {}",
1569 t.text
1570 );
1571 assert!(
1572 !t.text.contains("root compaction"),
1573 "should NOT contain root compaction"
1574 );
1575 }
1576 if let InfinityMessage::User {
1578 content: UserContent::Text(t),
1579 } = &history[1]
1580 {
1581 assert_eq!(t.text, "c3");
1582 }
1583 }
1584}