use super::*;
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TeammateMessage {
pub teammate_id: Option<String>,
pub signal_type: Option<String>,
}
#[allow(dead_code)]
impl TeammateMessage {
#[must_use]
pub fn is_signal(&self) -> bool {
self.signal_type.is_some()
}
}
pub(crate) fn has_boundary_section(content: &str, open: &str) -> bool {
let mut idx = 0;
while let Some(rel) = content[idx..].find(open) {
let start = idx + rel;
if is_section_boundary(&content[..start]) {
return true;
}
idx = start + open.len();
}
false
}
#[allow(dead_code)]
#[must_use]
pub fn is_teammate_message(content: &str) -> bool {
has_boundary_section(content, TEAMMATE_MESSAGE_OPEN)
}
#[allow(dead_code)]
#[must_use]
pub fn is_agent_message(content: &str) -> bool {
has_boundary_section(content, AGENT_MESSAGE_OPEN)
}
#[allow(dead_code)]
#[must_use]
pub fn is_cross_session_message(content: &str) -> bool {
has_boundary_section(content, CROSS_SESSION_MESSAGE_OPEN)
}
#[must_use]
pub fn is_peer_message(content: &str) -> bool {
is_teammate_message(content) || is_agent_message(content) || is_cross_session_message(content)
}
#[allow(dead_code)]
#[must_use]
pub fn parse_teammate_message(content: &str) -> Option<TeammateMessage> {
parse_all_teammate_messages(content).into_iter().next()
}
#[allow(dead_code)]
#[must_use]
pub fn parse_all_teammate_messages(content: &str) -> Vec<TeammateMessage> {
let mut out = Vec::new();
scan_tag_sections(
content,
TEAMMATE_MESSAGE_OPEN,
TEAMMATE_MESSAGE_CLOSE,
|_, section| {
out.push(TeammateMessage {
teammate_id: extract_xml_attr(section, "teammate_id"),
signal_type: teammate_signal_type(section),
});
},
);
out
}
pub(crate) fn is_section_boundary(prefix: &str) -> bool {
let t = prefix.trim_end();
t.is_empty()
|| PEER_MESSAGE_PREAMBLES.iter().any(|p| t.ends_with(p))
|| t.ends_with(TASK_NOTIFICATION_CLOSE)
|| t.ends_with(TEAMMATE_MESSAGE_CLOSE)
|| t.ends_with(AGENT_MESSAGE_CLOSE)
|| t.ends_with(CROSS_SESSION_MESSAGE_CLOSE)
}
pub(crate) fn scan_tag_sections<F: FnMut(usize, &str)>(
content: &str,
open: &str,
close: &str,
mut emit: F,
) {
let mut idx = 0;
while let Some(rel) = content[idx..].find(open) {
let start = idx + rel;
if !is_section_boundary(&content[..start]) {
idx = start + open.len();
continue;
}
let after = &content[start..];
let end_rel = after.find(close).map_or(after.len(), |c| c + close.len());
emit(start, &after[..end_rel]);
idx = start + end_rel;
}
}
pub(crate) fn cross_session_sender(section: &str) -> Option<String> {
extract_xml_attr(section, "from-name").or_else(|| extract_xml_attr(section, "from"))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PeerSection {
pub(crate) from: Option<String>,
pub(crate) is_signal: bool,
pub(crate) offset: usize,
pub(crate) text: String,
}
pub(crate) fn parse_all_peer_sections(content: &str) -> Vec<PeerSection> {
let mut out: Vec<PeerSection> = Vec::new();
scan_tag_sections(
content,
TEAMMATE_MESSAGE_OPEN,
TEAMMATE_MESSAGE_CLOSE,
|offset, section| {
out.push(PeerSection {
from: extract_xml_attr(section, "teammate_id"),
is_signal: teammate_signal_type(section).is_some(),
offset,
text: section.to_string(),
});
},
);
scan_tag_sections(
content,
AGENT_MESSAGE_OPEN,
AGENT_MESSAGE_CLOSE,
|offset, section| {
out.push(PeerSection {
from: extract_xml_attr(section, "from"),
is_signal: false,
offset,
text: section.to_string(),
});
},
);
scan_tag_sections(
content,
CROSS_SESSION_MESSAGE_OPEN,
CROSS_SESSION_MESSAGE_CLOSE,
|offset, section| {
out.push(PeerSection {
from: cross_session_sender(section),
is_signal: false,
offset,
text: section.to_string(),
});
},
);
out.sort_by_key(|p| p.offset);
out
}
pub(crate) fn peer_section_body(section: &str) -> &str {
let body = match section.find('>') {
Some(i) => §ion[i + 1..],
None => section,
};
body.strip_suffix(TEAMMATE_MESSAGE_CLOSE)
.or_else(|| body.strip_suffix(AGENT_MESSAGE_CLOSE))
.or_else(|| body.strip_suffix(CROSS_SESSION_MESSAGE_CLOSE))
.unwrap_or(body)
.trim()
}
impl Record {
pub(crate) fn peer_origin(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
let obj = self.origin.as_ref()?.as_object()?;
let peer = obj.get("kind").and_then(serde_json::Value::as_str) == Some("peer");
peer.then_some(obj)
}
fn peer_origin_str(&self, key: &str) -> Option<String> {
let v = self.peer_origin()?.get(key)?.as_str()?.trim();
(!v.is_empty()).then(|| v.to_string())
}
pub(crate) fn first_peer_from(&self) -> Option<String> {
if !self.is_type("user") {
return None;
}
let text = self.raw_message_text()?;
let secs = parse_all_peer_sections(&text);
let first = secs.first()?;
Some(peer_sender(self, first, secs.len() == 1))
}
#[must_use]
pub fn inbound_comm_preview(&self) -> Option<InboundComm> {
let text = self.raw_message_text()?;
let secs = parse_all_peer_sections(&text);
let first = secs.first()?;
let class = if first.is_signal {
Class::CommSignal
} else {
Class::CommInbox
};
Some(InboundComm {
class,
from: peer_sender(self, first, secs.len() == 1),
body: peer_render_body(self, first, secs.len() == 1),
})
}
}
pub(crate) fn peer_sender(rec: &Record, section: &PeerSection, single: bool) -> String {
if single {
if let Some(name) = rec.peer_origin_str("name") {
return name;
}
}
section.from.clone().unwrap_or_else(|| "peer".to_string())
}
pub(crate) fn peer_render_body(rec: &Record, section: &PeerSection, single: bool) -> String {
if single {
if let Some(body) = rec.peer_origin_str("body") {
return normalize_line(&body);
}
}
normalize_line(peer_section_body(§ion.text))
}
pub(crate) fn extract_xml_attr(s: &str, attr: &str) -> Option<String> {
let needle = format!("{attr}=\"");
let start = s.find(&needle)? + needle.len();
let rel = s[start..].find('"')?;
let val = s[start..start + rel].trim();
if val.is_empty() {
None
} else {
Some(val.to_string())
}
}
pub(crate) fn teammate_signal_type(after_open: &str) -> Option<String> {
let gt = after_open.find('>')?;
let body_start = gt + 1;
const CLOSE: &str = "</teammate-message>";
let body_end = after_open[body_start..]
.find(CLOSE)
.map_or(after_open.len(), |rel| body_start + rel);
let body = after_open[body_start..body_end].trim();
if !body.starts_with('{') {
return None;
}
let v: serde_json::Value = serde_json::from_str(body).ok()?;
v.get("type")
.and_then(serde_json::Value::as_str)
.filter(|s| !s.is_empty())
.map(str::to_string)
}
pub(crate) fn is_spawn_tool_name(name: &str) -> bool {
matches!(name, "Task" | "Agent" | "Workflow")
}
pub(crate) fn send_message_is_signal(input: Option<&serde_json::Value>) -> bool {
let Some(input) = input else {
return false;
};
let type_at = |v: &serde_json::Value| {
v.get("type")
.and_then(serde_json::Value::as_str)
.map(str::to_string)
};
if let Some(t) = type_at(input) {
return !matches!(t.as_str(), "message" | "direct");
}
if let Some(t) = input.get("message").and_then(type_at) {
return !matches!(t.as_str(), "message" | "direct");
}
false
}
pub(crate) fn send_message_recipient(input: Option<&serde_json::Value>) -> Option<String> {
let input = input?;
for key in ["to", "recipient"] {
if let Some(v) = input.get(key).and_then(serde_json::Value::as_str) {
if !v.is_empty() {
return Some(v.to_string());
}
}
}
None
}
pub(crate) fn spawn_target_name(input: Option<&serde_json::Value>) -> Option<String> {
let input = input?;
for key in ["name", "subagent_type"] {
if let Some(v) = input.get(key).and_then(serde_json::Value::as_str) {
if !v.is_empty() {
return Some(v.to_string());
}
}
}
None
}