1001. 1001 call_id.clone(),
1002. 1002 giant_output.clone(),
1003. 1003 )],
1004. 1004 },
1005. 1005 meta: None,
1006. 1006 })
1007. 1007 .unwrap();
1008. 1008 log.append_message(assistant_msg("found results")).unwrap();
1009. 1009
1010. 1010 // Turn 2: still open, with its own tool result.
1011. 1011 log.append_message(user_msg("now run python")).unwrap();
1012. 1012 let call_id_2 = "call-2".to_string();
1013. 1013 log.append_message(MessageRecord {
1014. 1014 message: Message {
1015. 1015 role: vak_llm::Role::Assistant,
1016. 1016 content: vec![vak_llm::ContentBlock::ToolUse {
1017. 1017 id: call_id_2.clone(),
1018. 1018 name: "python".into(),
1019. 1019 input: serde_json::json!({}),
1020. 1020 }],
1021. 1021 },
1022. 1022 meta: None,
1023. 1023 })
1024. 1024 .unwrap();
1025. 1025 log.append_message(MessageRecord {
1026. 1026 message: Message {
1027. 1027 role: vak_llm::Role::User,
1028. 1028 content: vec![vak_llm::ContentBlock::tool_result(
1029. 1029 call_id_2.clone(),
1030. 1030 "small output".to_string(),
1031. 1031 )],
1032. 1032 },
1033. 1033 meta: None,
1034. 1034 })
1035. 1035 .unwrap();
1036. 1036
1037. 1037 let messages = log.derive_messages();
1038. 1038
1039. 1039 // Turn 1 is closed: its tool_use/tool_result pair is still there (the
1040. 1040 // call pattern is what a later turn imitates), but the result is the
1041. 1041 // schema-driven digest naming the evidence id — never the 5,000 raw
1042. 1042 // characters and never a character-count trim marker.
1043. 1043 let closed_result = messages
1044. 1044 .iter()
1045. 1045 .flat_map(|m| m.content.iter())
1046. 1046 .find_map(|b| match b {
1047. 1047 vak_llm::ContentBlock::ToolResult {
1048. 1048 tool_use_id,
1049. 1049 content,
1050. 1050 ..
1051. 1051 } if tool_use_id == &call_id => Some(content.clone()),
1052. 1052 _ => None,
1053. 1053 })
1054. 1054 .expect("the closed turn keeps its tool_use/tool_result pair");
1055. 1055 assert!(
1056. 1056 closed_result.contains("[evidence:call-1"),
1057. 1057 "the digest must name the evidence id: {closed_result}"
1058. 1058 );
1059. 1059 assert!(
1060. 1060 !closed_result.contains(&giant_output),
1061. 1061 "a closed turn's tool result must not appear verbatim"
1062. 1062 );
1063. 1063 assert!(
1064. 1064 !closed_result.contains("trimmed"),
1065. 1065 "no character-count trim marker anywhere"
1066. 1066 );
1067. 1067
1068. 1068 // Turn 2 is still open: its tool result stays verbatim.
1069. 1069 let turn2_result = messages
1070. 1070 .iter()
1071. 1071 .find(|m| {
1072. 1072 m.content.iter().any(|b| {
1073. 1073 matches!(b, vak_llm::ContentBlock::ToolResult { tool_use_id, .. } if tool_use_id == &call_id_2)
1074. 1074 })
1075. 1075 })
1076. 1076 .expect("the open turn's tool result stays a raw block");
1077. 1077 let turn2_text = match &turn2_result.content[0] {
1078. 1078 vak_llm::ContentBlock::ToolResult { content, .. } => content,
1079. 1079 _ => unreachable!(),
1080. 1080 };
1081. 1081 assert_eq!(turn2_text, "small output");
1082. 1082
1083. 1083 // The full content is still recoverable whole, via evidence().
1084. 1084 let evidence = log
1085. 1085 .evidence(&call_id)
1086. 1086 .expect("evidence for a closed turn's call");
1087. 1087 assert_eq!(evidence.content.len(), 5_000);
1088. 1088 assert_eq!(evidence.tool, "search");
1089. 1089 assert!(!evidence.is_error);
1090. 1090}
1091. 1091