use std::collections::{HashMap, HashSet};
use crate::provider::{Message, Role, ToolCall};
fn missing_result_content(tool_name: &str) -> String {
format!(
"[TinyHarness] No output was recorded for this call to '{tool_name}' — the turn was \
aborted before the tool produced a result. Treat the call as never having run, and ask \
the user before repeating it."
)
}
fn placeholder_result(id: &str, tool_name: &str) -> Message {
Message {
role: Role::Tool,
content: missing_result_content(tool_name),
tool_calls: vec![],
tool_call_id: Some(id.to_string()),
images: vec![],
thinking: None,
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct ToolPairFixes {
pub stubbed: usize,
pub dropped: usize,
}
impl ToolPairFixes {
pub fn changed(&self) -> bool {
self.stubbed > 0 || self.dropped > 0
}
}
struct DeclaredCall {
id: String,
name: String,
owner: usize,
}
pub fn sanitize_tool_pairs(messages: &[Message]) -> (Vec<Message>, ToolPairFixes) {
let mut declared: Vec<DeclaredCall> = Vec::new();
let mut declared_ids: HashSet<String> = HashSet::new();
let mut normalized: Vec<Message> = Vec::with_capacity(messages.len());
let mut next_synthetic = 0_usize;
for message in messages {
let mut message = message.clone();
if message.role == Role::Assistant && !message.tool_calls.is_empty() {
let owner = normalized.len();
for call in &mut message.tool_calls {
let id = match usable_id(call) {
Some(candidate) if !declared_ids.contains(&candidate) => candidate,
_ => {
let id = format!("call_fixed_{next_synthetic}");
next_synthetic += 1;
id
}
};
call.id = Some(id.clone());
declared_ids.insert(id.clone());
declared.push(DeclaredCall {
name: call.function.name.clone(),
id,
owner,
});
}
}
normalized.push(message);
}
let mut binding: HashMap<usize, String> = HashMap::new();
let mut answered: HashSet<String> = HashSet::new();
let mut dropped = 0_usize;
let mut cursor = 0_usize;
for (index, message) in normalized.iter().enumerate() {
if message.role != Role::Tool {
continue;
}
let claimed = match message.tool_call_id.as_deref() {
Some(id) if !id.is_empty() => {
declared_ids.contains(id).then(|| id.to_string())
}
_ => {
while cursor < declared.len() && answered.contains(&declared[cursor].id) {
cursor += 1;
}
declared.get(cursor).map(|call| {
cursor += 1;
call.id.clone()
})
}
};
match claimed {
Some(id) if answered.insert(id.clone()) => {
binding.insert(index, id);
}
_ => dropped += 1,
}
}
let mut placeholders: HashMap<usize, Vec<DeclaredCall>> = HashMap::new();
for call in declared {
if !answered.contains(&call.id) {
placeholders.entry(call.owner).or_default().push(call);
}
}
let stubbed = placeholders.values().map(Vec::len).sum();
let mut out: Vec<Message> = Vec::with_capacity(normalized.len() + stubbed);
for (index, message) in normalized.into_iter().enumerate() {
match binding.get(&index) {
Some(id) => {
let mut message = message;
message.tool_call_id = Some(id.clone());
out.push(message);
}
None if message.role == Role::Tool => {
}
None => out.push(message),
}
if let Some(calls) = placeholders.get(&index) {
out.extend(
calls
.iter()
.map(|call| placeholder_result(&call.id, &call.name)),
);
}
}
(out, ToolPairFixes { stubbed, dropped })
}
pub fn repair_tool_pairs(messages: &mut Vec<Message>) -> ToolPairFixes {
let (repaired, fixes) = sanitize_tool_pairs(messages);
*messages = repaired;
fixes
}
fn usable_id(call: &ToolCall) -> Option<String> {
call.id.clone().filter(|id| !id.is_empty())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::provider::ToolCallFunction;
use serde_json::json;
fn call(id: Option<&str>, name: &str) -> ToolCall {
ToolCall {
id: id.map(str::to_string),
function: ToolCallFunction {
name: name.to_string(),
arguments: json!({}),
thought_signature: None,
},
}
}
fn assistant(calls: Vec<ToolCall>) -> Message {
Message {
role: Role::Assistant,
content: String::new(),
tool_calls: calls,
tool_call_id: None,
images: vec![],
thinking: None,
}
}
fn tool(id: Option<&str>, content: &str) -> Message {
Message {
role: Role::Tool,
content: content.to_string(),
tool_calls: vec![],
tool_call_id: id.map(str::to_string),
images: vec![],
thinking: None,
}
}
fn user(content: &str) -> Message {
Message::simple(Role::User, content)
}
fn system() -> Message {
Message::simple(Role::System, "sys")
}
fn ids_of(message: &Message) -> Vec<Option<String>> {
match message.role {
Role::Tool => vec![message.tool_call_id.clone()],
_ => message
.tool_calls
.iter()
.map(|call| call.id.clone())
.collect(),
}
}
fn assert_paired(messages: &[Message]) {
let mut declared: Vec<String> = Vec::new();
for message in messages {
if message.role == Role::Assistant {
declared.extend(message.tool_calls.iter().filter_map(|call| call.id.clone()));
}
}
let mut seen: HashSet<&str> = HashSet::new();
for message in messages {
if message.role != Role::Tool {
continue;
}
let id = message
.tool_call_id
.as_deref()
.expect("tool result must carry an id");
assert!(!id.is_empty(), "tool result id must not be empty");
assert!(
declared.iter().any(|declared| declared == id),
"result {id} has no declared call"
);
assert!(seen.insert(id), "call {id} answered twice");
}
assert_eq!(
seen.len(),
declared.len(),
"every declared call must be answered"
);
}
#[test]
fn correctly_paired_history_is_unchanged() {
let messages = vec![
system(),
user("hi"),
assistant(vec![call(Some("call_a"), "read")]),
tool(Some("call_a"), "contents"),
assistant(vec![
call(Some("call_b"), "ls"),
call(Some("call_c"), "glob"),
]),
tool(Some("call_b"), "entries"),
tool(Some("call_c"), "files"),
Message::simple(Role::Assistant, "done"),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert!(!fixes.changed());
assert_eq!(out.len(), messages.len());
for (before, after) in messages.iter().zip(&out) {
assert_eq!(before.role, after.role);
assert_eq!(before.content, after.content);
assert_eq!(ids_of(before), ids_of(after));
}
}
#[test]
fn unanswered_call_gets_placeholder() {
let messages = vec![
system(),
user("hi"),
assistant(vec![call(Some("call_2ab5e00d"), "edit")]),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert_eq!(
fixes,
ToolPairFixes {
stubbed: 1,
dropped: 0
}
);
assert_paired(&out);
assert_eq!(out.len(), 4);
assert_eq!(out[3].role, Role::Tool);
assert_eq!(out[3].tool_call_id.as_deref(), Some("call_2ab5e00d"));
assert!(out[3].content.contains("edit"));
assert!(out[3].content.contains("No output was recorded"));
}
#[test]
fn orphan_result_is_dropped() {
let messages = vec![
system(),
tool(Some("call_gone"), "stale output"),
user("keep going"),
Message::simple(Role::Assistant, "sure"),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert_eq!(
fixes,
ToolPairFixes {
stubbed: 0,
dropped: 1
}
);
assert_eq!(out.len(), 3);
assert!(!out.iter().any(|m| m.content == "stale output"));
assert_paired(&out);
}
#[test]
fn duplicate_result_is_dropped_but_first_wins() {
let messages = vec![
system(),
assistant(vec![call(Some("call_a"), "read")]),
tool(Some("call_a"), "real output"),
tool(Some("call_a"), "second output"),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert_eq!(
fixes,
ToolPairFixes {
stubbed: 0,
dropped: 1
}
);
assert_paired(&out);
let result = out
.iter()
.find(|m| m.role == Role::Tool)
.expect("one result");
assert_eq!(result.content, "real output");
}
#[test]
fn missing_call_id_is_synthesized_and_echoed_in_placeholder() {
let messages = vec![
system(),
assistant(vec![call(None, "grep"), call(Some(""), "glob")]),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert_eq!(fixes.stubbed, 2);
assert_paired(&out);
let assistant = &out[1];
let first = assistant.tool_calls[0].id.as_deref().unwrap();
let second = assistant.tool_calls[1].id.as_deref().unwrap();
assert_eq!(first, "call_fixed_0");
assert_eq!(second, "call_fixed_1");
assert_eq!(out[2].tool_call_id.as_deref(), Some(first));
assert_eq!(out[3].tool_call_id.as_deref(), Some(second));
}
#[test]
fn result_without_id_binds_positionally() {
let messages = vec![
system(),
assistant(vec![call(None, "read"), call(None, "ls")]),
tool(None, "file contents"),
tool(None, "directory entries"),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert!(!fixes.changed());
assert_paired(&out);
let results: Vec<&Message> = out.iter().filter(|m| m.role == Role::Tool).collect();
assert_eq!(results[0].content, "file contents");
assert_eq!(results[1].content, "directory entries");
assert_eq!(results[0].tool_call_id.as_deref(), Some("call_fixed_0"));
assert_eq!(results[1].tool_call_id.as_deref(), Some("call_fixed_1"));
}
#[test]
fn idless_result_binds_only_to_unanswered_calls() {
let messages = vec![
system(),
assistant(vec![
call(Some("call_a"), "read"),
call(Some("call_b"), "ls"),
]),
tool(Some("call_a"), "first"),
tool(None, "second"),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert!(!fixes.changed());
assert_paired(&out);
let results: Vec<&Message> = out.iter().filter(|m| m.role == Role::Tool).collect();
assert_eq!(results[1].tool_call_id.as_deref(), Some("call_b"));
assert_eq!(results[1].content, "second");
}
#[test]
fn result_scattered_after_an_intervening_message_is_kept() {
let messages = vec![
system(),
assistant(vec![
call(Some("call_s"), "invoke_skill"),
call(Some("call_r"), "read"),
]),
tool(Some("call_s"), "skill activated"),
user("/use review"),
tool(Some("call_r"), "file contents"),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert!(!fixes.changed());
assert_eq!(out.len(), 5);
assert_paired(&out);
}
#[test]
fn placeholder_lands_next_to_its_owner() {
let messages = vec![
system(),
assistant(vec![call(Some("call_x"), "run")]),
user("actually, stop"),
Message::simple(Role::Assistant, "ok"),
];
let (out, fixes) = sanitize_tool_pairs(&messages);
assert_eq!(fixes.stubbed, 1);
assert_paired(&out);
assert_eq!(out[1].role, Role::Assistant);
assert_eq!(out[2].role, Role::Tool);
assert_eq!(out[2].tool_call_id.as_deref(), Some("call_x"));
assert_eq!(out[3].role, Role::User);
}
#[test]
fn duplicate_call_ids_are_made_unique() {
let messages = vec![
system(),
assistant(vec![
call(Some("call_a"), "read"),
call(Some("call_a"), "ls"),
]),
tool(Some("call_a"), "first output"),
tool(Some("call_a"), "second output"),
];
let (out, _) = sanitize_tool_pairs(&messages);
assert_paired(&out);
let assistant = &out[1];
assert_ne!(
assistant.tool_calls[0].id, assistant.tool_calls[1].id,
"ids must be unique"
);
assert_eq!(assistant.tool_calls[1].id.as_deref(), Some("call_fixed_0"));
}
#[test]
fn empty_history_round_trips() {
let (out, fixes) = sanitize_tool_pairs(&[]);
assert!(out.is_empty());
assert!(!fixes.changed());
}
#[test]
fn system_prompt_stays_first() {
let messages = vec![system(), assistant(vec![call(Some("call_a"), "read")])];
let (out, _) = sanitize_tool_pairs(&messages);
assert_eq!(out[0].role, Role::System);
assert_eq!(out[0].content, "sys");
assert_paired(&out);
}
#[test]
fn repair_is_idempotent() {
let messages = vec![
system(),
assistant(vec![call(Some("call_a"), "read")]),
tool(Some("call_b"), "orphan"),
user("next"),
assistant(vec![call(Some("call_c"), "write")]),
];
let (once, first_fixes) = sanitize_tool_pairs(&messages);
assert_paired(&once);
assert!(first_fixes.changed());
let (twice, second_fixes) = sanitize_tool_pairs(&once);
assert!(!second_fixes.changed(), "a repaired history is stable");
assert_eq!(twice.len(), once.len());
}
#[test]
fn in_place_repair_matches_sanitize() {
let messages = vec![system(), assistant(vec![call(Some("call_a"), "edit")])];
let expected_len = sanitize_tool_pairs(&messages).0.len();
let mut repaired = messages.clone();
let fixes = repair_tool_pairs(&mut repaired);
assert_eq!(fixes.stubbed, 1);
assert_eq!(repaired.len(), expected_len);
assert_paired(&repaired);
}
}