huskies: merge 1125 story LLM session entity + assemble_prompt_context helper, wired into Matrix bot
This commit is contained in:
dave
@@ -0,0 +1,221 @@
|
||||
//! Read/write helpers for the `llm_sessions` LWW-map collection, including the
|
||||
//! atomic `assemble_and_advance_session` helper used by the Matrix bot.
|
||||
//!
|
||||
//! LLM sessions are keyed by `session_id` (typically a Matrix room ID) and track
|
||||
//! per-sled high-water marks so that `assemble_and_advance_session` can inject
|
||||
//! only events the LLM has not yet seen and advance the marks atomically within
|
||||
//! a single CRDT lock acquisition.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use bft_json_crdt::json_crdt::{JsonValue, *};
|
||||
use bft_json_crdt::op::ROOT_ID;
|
||||
use serde_json::json;
|
||||
|
||||
use super::super::state::{apply_and_persist, get_crdt, rebuild_llm_session_index};
|
||||
use super::super::types::{LlmSessionCrdt, LlmSessionView};
|
||||
|
||||
/// Write or upsert an LLM session entry keyed by `session_id`.
|
||||
///
|
||||
/// Creates a new entry if `session_id` is not yet present; updates
|
||||
/// `persona_name` and `scope` on an existing entry. The `high_water`
|
||||
/// register is not touched by this function — use `assemble_and_advance_session`
|
||||
/// to advance it atomically.
|
||||
pub fn write_llm_session(session_id: &str, persona_name: &str, scope: &str) {
|
||||
let Some(state_mutex) = get_crdt() else {
|
||||
return;
|
||||
};
|
||||
let Ok(mut state) = state_mutex.lock() else {
|
||||
return;
|
||||
};
|
||||
|
||||
if let Some(&idx) = state.llm_session_index.get(session_id) {
|
||||
apply_and_persist(&mut state, |s| {
|
||||
s.crdt.doc.llm_sessions[idx]
|
||||
.persona_name
|
||||
.set(persona_name.to_string())
|
||||
});
|
||||
apply_and_persist(&mut state, |s| {
|
||||
s.crdt.doc.llm_sessions[idx].scope.set(scope.to_string())
|
||||
});
|
||||
} else {
|
||||
let entry: JsonValue = json!({
|
||||
"session_id": session_id,
|
||||
"persona_name": persona_name,
|
||||
"scope": scope,
|
||||
"high_water": "{}",
|
||||
})
|
||||
.into();
|
||||
apply_and_persist(&mut state, |s| {
|
||||
s.crdt.doc.llm_sessions.insert(ROOT_ID, entry)
|
||||
});
|
||||
state.llm_session_index = rebuild_llm_session_index(&state.crdt);
|
||||
}
|
||||
}
|
||||
|
||||
/// Read a single LLM session entry by `session_id`.
|
||||
pub fn read_llm_session(session_id: &str) -> Option<LlmSessionView> {
|
||||
let state_mutex = get_crdt()?;
|
||||
let state = state_mutex.lock().ok()?;
|
||||
let &idx = state.llm_session_index.get(session_id)?;
|
||||
extract_llm_session_view(&state.crdt.doc.llm_sessions[idx])
|
||||
}
|
||||
|
||||
/// Atomically read new event-log entries for `session_id` past the stored
|
||||
/// high-water marks, render them as a block of audit lines, and advance the
|
||||
/// marks to prevent double-injection on the next call.
|
||||
///
|
||||
/// Scope is "single-sled": only events recorded by the local node (identified
|
||||
/// via [`crate::crdt_state::our_node_id`]) are included. Events from other
|
||||
/// sleds are ignored in this story.
|
||||
///
|
||||
/// Returns an empty `Vec` when there are no new events or the CRDT is not
|
||||
/// initialised.
|
||||
pub fn assemble_and_advance_session(session_id: &str) -> Vec<String> {
|
||||
let local_sled_id = crate::crdt_state::our_node_id().unwrap_or_default();
|
||||
if local_sled_id.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
|
||||
let Some(state_mutex) = get_crdt() else {
|
||||
return Vec::new();
|
||||
};
|
||||
let Ok(mut state) = state_mutex.lock() else {
|
||||
return Vec::new();
|
||||
};
|
||||
|
||||
// Read the current high-water map for this session.
|
||||
let current_high_water: BTreeMap<String, u64> = {
|
||||
match state.llm_session_index.get(session_id).copied() {
|
||||
Some(idx) => parse_high_water(&state.crdt.doc.llm_sessions[idx]),
|
||||
None => BTreeMap::new(),
|
||||
}
|
||||
};
|
||||
|
||||
let last_seen = current_high_water.get(&local_sled_id).copied();
|
||||
|
||||
// Collect new events from the local sled past the high-water mark.
|
||||
let new_events: Vec<(u64, String, String, String, String)> = state
|
||||
.crdt
|
||||
.doc
|
||||
.event_log
|
||||
.iter()
|
||||
.filter_map(|e| extract_new_event(e, &local_sled_id, last_seen))
|
||||
.collect();
|
||||
|
||||
if new_events.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
|
||||
// Advance the high-water mark to the maximum new event_seq.
|
||||
let new_max_seq = new_events.iter().map(|(seq, ..)| *seq).max().unwrap_or(0);
|
||||
let mut new_high_water = current_high_water;
|
||||
new_high_water.insert(local_sled_id, new_max_seq);
|
||||
let new_hw_json = serde_json::to_string(&new_high_water).unwrap_or_else(|_| "{}".to_string());
|
||||
|
||||
// Upsert the session entry with the new high-water value.
|
||||
let idx_opt = state.llm_session_index.get(session_id).copied();
|
||||
if let Some(idx) = idx_opt {
|
||||
apply_and_persist(&mut state, |s| {
|
||||
s.crdt.doc.llm_sessions[idx]
|
||||
.high_water
|
||||
.set(new_hw_json.clone())
|
||||
});
|
||||
} else {
|
||||
let entry: JsonValue = json!({
|
||||
"session_id": session_id,
|
||||
"persona_name": "",
|
||||
"scope": "single-sled",
|
||||
"high_water": new_hw_json,
|
||||
})
|
||||
.into();
|
||||
apply_and_persist(&mut state, |s| {
|
||||
s.crdt.doc.llm_sessions.insert(ROOT_ID, entry)
|
||||
});
|
||||
state.llm_session_index = rebuild_llm_session_index(&state.crdt);
|
||||
}
|
||||
|
||||
// Render each new event as a compact audit line.
|
||||
new_events
|
||||
.into_iter()
|
||||
.map(|(_, story_id, from_stage, to_stage, pipeline_event)| {
|
||||
format!(
|
||||
"pipeline_event story_id=\"{story_id}\" from=\"{from_stage}\" \
|
||||
to=\"{to_stage}\" event=\"{pipeline_event}\""
|
||||
)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Decode the high-water JSON string from an `LlmSessionCrdt` entry.
|
||||
fn parse_high_water(entry: &LlmSessionCrdt) -> BTreeMap<String, u64> {
|
||||
match entry.high_water.view() {
|
||||
JsonValue::String(s) if !s.is_empty() && s != "{}" => {
|
||||
serde_json::from_str(&s).unwrap_or_default()
|
||||
}
|
||||
_ => BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Extract one event log entry if it belongs to `sled_id` and has an
|
||||
/// `event_seq` strictly greater than `last_seen` (or `last_seen` is `None`,
|
||||
/// meaning all events from this sled are new).
|
||||
fn extract_new_event(
|
||||
e: &crate::crdt_state::types::EventLogEntryCrdt,
|
||||
sled_id: &str,
|
||||
last_seen: Option<u64>,
|
||||
) -> Option<(u64, String, String, String, String)> {
|
||||
let entry_sled = match e.sled_id.view() {
|
||||
JsonValue::String(s) if s == sled_id => s,
|
||||
_ => return None,
|
||||
};
|
||||
let event_seq = match e.event_seq.view() {
|
||||
JsonValue::Number(n) => n as u64,
|
||||
_ => return None,
|
||||
};
|
||||
// Skip if we've already injected this event.
|
||||
if last_seen.is_some_and(|last| event_seq <= last) {
|
||||
return None;
|
||||
}
|
||||
let story_id = match e.story_id.view() {
|
||||
JsonValue::String(s) => s,
|
||||
_ => String::new(),
|
||||
};
|
||||
let from_stage = match e.from_stage.view() {
|
||||
JsonValue::String(s) => s,
|
||||
_ => String::new(),
|
||||
};
|
||||
let to_stage = match e.to_stage.view() {
|
||||
JsonValue::String(s) => s,
|
||||
_ => String::new(),
|
||||
};
|
||||
let pipeline_event = match e.pipeline_event.view() {
|
||||
JsonValue::String(s) => s,
|
||||
_ => String::new(),
|
||||
};
|
||||
let _ = entry_sled; // used only for filtering above
|
||||
Some((event_seq, story_id, from_stage, to_stage, pipeline_event))
|
||||
}
|
||||
|
||||
/// Convert a CRDT LLM session entry into its read-only view representation.
|
||||
pub(super) fn extract_llm_session_view(entry: &LlmSessionCrdt) -> Option<LlmSessionView> {
|
||||
let session_id = match entry.session_id.view() {
|
||||
JsonValue::String(s) if !s.is_empty() => s,
|
||||
_ => return None,
|
||||
};
|
||||
let persona_name = match entry.persona_name.view() {
|
||||
JsonValue::String(s) => s,
|
||||
_ => String::new(),
|
||||
};
|
||||
let scope = match entry.scope.view() {
|
||||
JsonValue::String(s) => s,
|
||||
_ => String::new(),
|
||||
};
|
||||
let high_water = parse_high_water(entry);
|
||||
Some(LlmSessionView {
|
||||
session_id,
|
||||
persona_name,
|
||||
scope,
|
||||
high_water,
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user