Assistant: drop earlier thinking blocks when history is trimmed, so Claude requests stop failing (#9417) (#9448)

* claim: #9417

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Assistant: drop earlier thinking blocks when history is trimmed (#9417)

Claude signs each thinking block against the conversation before it. Once
drop_old_views swaps an older view for a note, or trim_history drops the
oldest messages, every later block stops matching and the API refuses the
request with HTTP 400 "Invalid signature in thinking block". For the
Anthropic protocol, a trim now also removes the thinking and
redacted_thinking blocks from earlier replies, which the API allows. A
reply that was only thinking keeps a short note. Requests where nothing
was trimmed are sent unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
AsTechEvolves
2026-10-30 16:13:35 +00:00
committed by GitHub
parent 71b3a70254
commit b1c132bc9a
+93 -8
View File
@@ -30,6 +30,7 @@ const MAX_HISTORY: usize = 240;
const MAX_HISTORY_IMAGES: usize = 2;
/// What an older view becomes in the history.
const DROPPED_VIEW_NOTE: &str = "[an earlier picture of the view, removed to keep the request small]";
const DROPPED_THINKING_NOTE: &str = "[earlier reasoning, removed with older history]";
/// How long one tool call may take (it may wait for the user's Allow, declined after four
/// minutes). It does not depend on the endpoint's request timeout: a tool call is SolidCraft's own
/// work and the user's answer, never a wait for the model, so a longer request timeout does not
@@ -876,8 +877,11 @@ impl Worker {
fn turn(&mut self, parts: Vec<PromptPart>) {
self.history.push(user_message(self.cfg.protocol, &parts));
drop_old_views(&mut self.history, MAX_HISTORY_IMAGES);
self.trim_history();
let dropped = drop_old_views(&mut self.history, MAX_HISTORY_IMAGES);
let trimmed = self.trim_history();
if (dropped || trimmed) && self.cfg.protocol == Protocol::Anthropic {
drop_thinking(&mut self.history);
}
// No cap on requests: Stop sets `cancel`, checked at the top of every round.
loop {
// The history as of here is complete (every tool call answered): a cancelled request
@@ -964,14 +968,16 @@ impl Worker {
}
/// Keep the conversation bounded and starting at a user message, so neither protocol sees a
/// reply or a tool result without the message it answers.
fn trim_history(&mut self) {
/// reply or a tool result without the message it answers. True when a message was removed.
fn trim_history(&mut self) -> bool {
let before = self.history.len();
while self.history.len() > MAX_HISTORY {
self.history.remove(0);
}
while self.history.first().is_some_and(|m| !starts_a_turn(m)) {
self.history.remove(0);
}
self.history.len() != before
}
fn request(&self) -> Result<Reply, String> {
@@ -1443,9 +1449,11 @@ fn anthropic_reply(body: &Value) -> Reply {
/// Keeps the newest `keep` pictures of the view in the history and swaps every older one for a
/// short note, so the model still knows a view was shown. Text is never touched. Pictures come
/// as OpenAI `image_url` parts or Anthropic `image` blocks, depending on the endpoint.
fn drop_old_views(history: &mut [Value], keep: usize) {
/// as OpenAI `image_url` parts or Anthropic `image` blocks, depending on the endpoint. True when
/// a picture was swapped.
fn drop_old_views(history: &mut [Value], keep: usize) -> bool {
let mut seen = 0;
let mut dropped = false;
for msg in history.iter_mut().rev() {
let Some(content) = msg.get_mut("content").and_then(Value::as_array_mut) else { continue };
for part in content.iter_mut().rev() {
@@ -1455,9 +1463,26 @@ fn drop_old_views(history: &mut [Value], keep: usize) {
seen += 1;
if seen > keep {
*part = json!({"type": "text", "text": DROPPED_VIEW_NOTE});
dropped = true;
}
}
}
dropped
}
/// Takes Anthropic thinking blocks out of every earlier reply. Each one is signed against all
/// the conversation before it, so once a dropped view or trimmed message changes that, the API
/// refuses the whole request (#9417); leaving earlier thinking out is allowed. A reply that was
/// only thinking keeps a note, as the API takes no assistant message without content.
fn drop_thinking(history: &mut [Value]) {
for msg in history.iter_mut().filter(|m| m["role"] == "assistant") {
let Some(content) = msg.get_mut("content").and_then(Value::as_array_mut) else { continue };
let before = content.len();
content.retain(|b| !matches!(b.get("type").and_then(Value::as_str), Some("thinking" | "redacted_thinking")));
if content.is_empty() && before > 0 {
content.push(json!({"type": "text", "text": DROPPED_THINKING_NOTE}));
}
}
}
/// MCP `tools/list` as OpenAI function tools (the hidden ones left out).
@@ -1731,12 +1756,12 @@ mod tests {
#[test]
fn only_the_newest_views_stay_in_the_history_and_older_ones_become_a_note() {
let mut h = vec![json!({"role": "system", "content": "note"}), view(1), json!({"role": "assistant", "content": "ok"}), view(2)];
drop_old_views(&mut h, 2);
assert!(!drop_old_views(&mut h, 2));
assert_eq!(pictures(&h).len(), 2, "two views fit, nothing is dropped");
h.push(json!({"role": "user", "content": "plain text"}));
h.push(view(3));
drop_old_views(&mut h, 2);
assert!(drop_old_views(&mut h, 2));
assert_eq!(pictures(&h), vec!["data:image/png;base64,V2", "data:image/png;base64,V3"]);
// The oldest view is a note now; the words sent with it, and every other message, stay.
assert_eq!(h[1]["content"][0]["text"], "look 1");
@@ -2708,6 +2733,66 @@ mod tests {
b.shutdown(true);
}
/// Thinking blocks are signed against the conversation before them: once an older view is
/// dropped, the earlier ones go too, or Claude refuses the request (#9417). Until then, and
/// for replies after the drop, they are sent back as they came.
#[test]
fn a_dropped_view_takes_earlier_thinking_with_it() {
let seen = Arc::new(std::sync::Mutex::new(Vec::<Value>::new()));
let log = seen.clone();
let http: HttpFn = Arc::new(move |r: &HttpRequest| {
if r.method == "GET" {
return Ok((200, b"{\"data\":[]}".to_vec()));
}
let n = {
let mut l = log.lock().unwrap();
l.push(serde_json::from_slice(r.body.as_deref().unwrap_or(b"null")).unwrap());
l.len()
};
let content = if n == 2 {
json!([{"type": "redacted_thinking", "data": "r2"}])
} else {
json!([{"type": "thinking", "thinking": "", "signature": format!("s{n}")}, {"type": "text", "text": format!("Seen {n}.")}])
};
Ok((200, json!({"content": content, "stop_reason": "end_turn"}).to_string().into_bytes()))
});
let cfg = ApiConfig {
name: "Test".into(),
protocol: Protocol::Anthropic,
base_url: "http://localhost:1".into(),
model: "m".into(),
key: Some("sk-secret".into()),
http,
request_timeout_s: 300,
};
let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };
let mut b = ApiBackend::start(cfg, ctx).unwrap();
for n in 1..=3 {
b.prompt(&[PromptPart::Text(format!("look {n}")), PromptPart::Image { mime: "image/png".into(), base64: format!("V{n}") }]);
wait_for_turn(&mut b);
}
b.prompt(&[PromptPart::Text("and now?".into())]);
wait_for_turn(&mut b);
b.shutdown(true);
let sent = seen.lock().unwrap();
assert_eq!(sent.len(), 4);
let replies = |i: usize| -> Vec<Value> {
sent[i]["messages"].as_array().unwrap().iter().filter(|m| m["role"] == "assistant").map(|m| m["content"].clone()).collect()
};
// Two views fit: the reply goes back untouched, signature and all.
assert_eq!(replies(1)[0][0]["signature"], "s1");
// The third view drops the first: no earlier thinking is left, a thinking-only reply
// keeps a note, and the words stay.
let third = replies(2);
assert_eq!(sent[2]["messages"][0]["content"][1]["text"], DROPPED_VIEW_NOTE);
assert_eq!(third[0], json!([{"type": "text", "text": "Seen 1."}]));
assert_eq!(third[1], json!([{"type": "text", "text": DROPPED_THINKING_NOTE}]));
// Nothing is dropped for the next message, so the reply after the drop keeps its thinking.
let fourth = replies(3);
assert_eq!(fourth[..2], third[..]);
assert_eq!(fourth[2][0]["signature"], "s3");
}
#[test]
fn the_anthropic_test_sends_one_small_message_and_checks_the_key_rule() {
let seen = Arc::new(std::sync::Mutex::new(Vec::<HttpRequest>::new()));