mirror of
https://github.com/instructkr/claw-code.git
synced 2026-11-16 00:00:40 +08:00
fix: parallel tool-result pairing, terminal-scope path limit, credential hint
Merge PR #3360 from c01dsummer/claw-code (fix/roadmap-835-838) Four fixes addressing issues #3361 and #3360: 1. Parallel tool-result pairing (835): The Anthropic Messages API requires all tool results of a turn to be in a single message. When a turn issued two tool calls at once, the results were sent in separate messages, causing a 400 error. Fixed by merging adjacent tool-result-only messages into one. 2. Terminal-scope path limit (836): Correlation keys up to 512 bytes expanded to 1024+ hex characters, exceeding APFS's 1024-byte total path limit. Fixed by using SHA256 digest (32 hex chars) for path components while storing the full key in the record for exact matching. 3. Credential hint (838): When ANTHROPIC_BASE_URL points to a non-Anthropic endpoint (DeepSeek, corporate gateways), the missing-credentials error now explains that the endpoint expects its own credentials, not Anthropic's. 4. ROADMAP entries: Documents all three fixes with verification details. All tests pass (370+ for rusty-claude-cli, 240+ for sdk, 122+ for tools, 209+ for api). Formatting verified with cargo fmt. CI checks approved and passed. Fixes #3361, #3360
This commit is contained in:
1 parent
c55c7e4710
commit
b8f93afbb3
11 files changed
+970
-120
No files matched your search
@@ -20,5 +20,8 @@ aspect-macros = "0.1"
|
||||
aspect-std = "0.1"
|
||||
log = "0.4"
|
||||
|
||||
[dev-dependencies]
|
||||
mock-anthropic-service = { path = "../mock-anthropic-service" }
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
+289
-52
@@ -5525,52 +5525,97 @@ fn tool_specs_for_allowed_tools(allowed_tools: Option<&BTreeSet<String>>) -> Vec
|
||||
fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {
|
||||
messages
|
||||
.iter()
|
||||
.filter_map(|message| {
|
||||
let role = match message.role {
|
||||
MessageRole::System | MessageRole::User | MessageRole::Tool => "user",
|
||||
MessageRole::Assistant => "assistant",
|
||||
};
|
||||
let content = message
|
||||
.blocks
|
||||
.iter()
|
||||
.map(|block| match block {
|
||||
ContentBlock::Text { text } => InputContentBlock::Text { text: text.clone() },
|
||||
ContentBlock::Thinking {
|
||||
thinking,
|
||||
signature,
|
||||
} => InputContentBlock::Thinking {
|
||||
thinking: thinking.clone(),
|
||||
signature: signature.clone(),
|
||||
},
|
||||
ContentBlock::ToolUse { id, name, input } => InputContentBlock::ToolUse {
|
||||
id: id.clone(),
|
||||
name: name.clone(),
|
||||
input: serde_json::from_str(input)
|
||||
.unwrap_or_else(|_| serde_json::json!({ "raw": input })),
|
||||
},
|
||||
ContentBlock::ToolResult {
|
||||
tool_use_id,
|
||||
output,
|
||||
is_error,
|
||||
..
|
||||
} => InputContentBlock::ToolResult {
|
||||
tool_use_id: tool_use_id.clone(),
|
||||
content: vec![ToolResultContentBlock::Text {
|
||||
text: output.clone(),
|
||||
}],
|
||||
is_error: *is_error,
|
||||
},
|
||||
})
|
||||
.filter(
|
||||
|block| !matches!(block, InputContentBlock::Text { text } if text.is_empty()),
|
||||
)
|
||||
.collect::<Vec<_>>();
|
||||
(!content.is_empty()).then(|| InputMessage {
|
||||
role: role.to_string(),
|
||||
content,
|
||||
})
|
||||
.filter_map(convert_message)
|
||||
.fold(Vec::new(), absorb_tool_result_message)
|
||||
}
|
||||
|
||||
/// Converts one conversation message into its wire form.
|
||||
fn convert_message(message: &ConversationMessage) -> Option<InputMessage> {
|
||||
let role = match message.role {
|
||||
MessageRole::System | MessageRole::User | MessageRole::Tool => "user",
|
||||
MessageRole::Assistant => "assistant",
|
||||
};
|
||||
let content = message
|
||||
.blocks
|
||||
.iter()
|
||||
.map(|block| match block {
|
||||
ContentBlock::Text { text } => InputContentBlock::Text { text: text.clone() },
|
||||
ContentBlock::Thinking {
|
||||
thinking,
|
||||
signature,
|
||||
} => InputContentBlock::Thinking {
|
||||
thinking: thinking.clone(),
|
||||
signature: signature.clone(),
|
||||
},
|
||||
ContentBlock::ToolUse { id, name, input } => InputContentBlock::ToolUse {
|
||||
id: id.clone(),
|
||||
name: name.clone(),
|
||||
input: serde_json::from_str(input)
|
||||
.unwrap_or_else(|_| serde_json::json!({ "raw": input })),
|
||||
},
|
||||
ContentBlock::ToolResult {
|
||||
tool_use_id,
|
||||
output,
|
||||
is_error,
|
||||
..
|
||||
} => InputContentBlock::ToolResult {
|
||||
tool_use_id: tool_use_id.clone(),
|
||||
content: vec![ToolResultContentBlock::Text {
|
||||
text: output.clone(),
|
||||
}],
|
||||
is_error: *is_error,
|
||||
},
|
||||
})
|
||||
.collect()
|
||||
.filter(|block| !matches!(block, InputContentBlock::Text { text } if text.is_empty()))
|
||||
.collect::<Vec<_>>();
|
||||
(!content.is_empty()).then(|| InputMessage {
|
||||
role: role.to_string(),
|
||||
content,
|
||||
})
|
||||
}
|
||||
|
||||
/// Identical in `rusty-claude-cli` and `tools`; kept in both copies by review
|
||||
/// decision rather than shared, but they must still be changed together.
|
||||
///
|
||||
/// The two `convert_messages` call sites are not interchangeable: `tools` drops
|
||||
/// empty `Text` blocks and the CLI keeps them. That difference is confined to
|
||||
/// `convert_message`, so it constrains hoisting the whole conversion, not this
|
||||
/// fold. It is reachable when history is not built from the model stream — an
|
||||
/// empty `user_text("")` or a persisted `"text":""` restored from a session log
|
||||
/// bypasses the `flush_text_block` filter that the streaming path applies.
|
||||
/// Appends a message, merging a run of pure tool-result messages into one.
|
||||
///
|
||||
/// `runtime` records one `MessageRole::Tool` message per tool call, but the
|
||||
/// Anthropic Messages API requires every `tool_use` of an assistant turn to be
|
||||
/// answered by `tool_result` blocks in the single message that follows it, so a
|
||||
/// parallel tool-call turn must not reach the provider as one message per
|
||||
/// result. A merge requires both the accumulated message and the incoming one to
|
||||
/// be pure tool results: checking only the accumulated side would fold the
|
||||
/// assistant reply that follows a tool result into the tool-result message and
|
||||
/// lose its role.
|
||||
fn absorb_tool_result_message(
|
||||
mut messages: Vec<InputMessage>,
|
||||
message: InputMessage,
|
||||
) -> Vec<InputMessage> {
|
||||
if is_tool_result_only(&message) {
|
||||
if let Some(previous) = messages.last_mut() {
|
||||
if previous.role == "user" && is_tool_result_only(previous) {
|
||||
previous.content.extend(message.content);
|
||||
return messages;
|
||||
}
|
||||
}
|
||||
}
|
||||
messages.push(message);
|
||||
messages
|
||||
}
|
||||
|
||||
/// Reports whether a wire message carries tool results and nothing else.
|
||||
fn is_tool_result_only(message: &InputMessage) -> bool {
|
||||
!message.content.is_empty()
|
||||
&& message
|
||||
.content
|
||||
.iter()
|
||||
.all(|block| matches!(block, InputContentBlock::ToolResult { .. }))
|
||||
}
|
||||
|
||||
fn push_output_block(
|
||||
@@ -6976,19 +7021,20 @@ mod tests {
|
||||
use std::time::Duration;
|
||||
|
||||
use super::{
|
||||
agent_permission_policy, allowed_tools_for_subagent, build_agent_system_prompt,
|
||||
classify_lane_failure, derive_agent_state, execute_agent_with_spawn, execute_tool,
|
||||
extract_recovery_outcome, final_assistant_text, global_cron_registry,
|
||||
maybe_commit_provenance, mvp_tool_specs, permission_mode_from_plugin,
|
||||
absorb_tool_result_message, agent_permission_policy, allowed_tools_for_subagent,
|
||||
build_agent_system_prompt, classify_lane_failure, convert_message, derive_agent_state,
|
||||
execute_agent_with_spawn, execute_tool, extract_recovery_outcome, final_assistant_text,
|
||||
global_cron_registry, maybe_commit_provenance, mvp_tool_specs, permission_mode_from_plugin,
|
||||
persist_agent_terminal_state, push_output_block, run_task_packet, AgentInput, AgentJob,
|
||||
GlobalToolRegistry, LaneEventName, LaneFailureClass, ProviderRuntimeClient,
|
||||
SubagentToolExecutor,
|
||||
};
|
||||
use api::OutputContentBlock;
|
||||
use api::{InputContentBlock, InputMessage, OutputContentBlock};
|
||||
use runtime::ProviderFallbackConfig;
|
||||
use runtime::{
|
||||
permission_enforcer::PermissionEnforcer, ApiRequest, AssistantEvent, ConversationRuntime,
|
||||
PermissionMode, PermissionPolicy, RuntimeError, Session, TaskPacket, ToolExecutor,
|
||||
permission_enforcer::PermissionEnforcer, ApiClient, ApiRequest, AssistantEvent,
|
||||
ContentBlock, ConversationMessage, ConversationRuntime, PermissionMode, PermissionPolicy,
|
||||
RuntimeError, Session, TaskPacket, ToolExecutor,
|
||||
};
|
||||
use serde_json::json;
|
||||
|
||||
@@ -11063,4 +11109,195 @@ printf 'pwsh:%s' "$1"
|
||||
.into_bytes()
|
||||
}
|
||||
}
|
||||
fn tool_result_message(id: &str) -> runtime::ConversationMessage {
|
||||
ConversationMessage::tool_result(id, "bash", "ok", false)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn subagent_parallel_tool_results_share_one_message() {
|
||||
let messages = vec![
|
||||
ConversationMessage::user_text("go"),
|
||||
ConversationMessage::assistant(vec![
|
||||
ContentBlock::ToolUse {
|
||||
id: "tool-1".to_string(),
|
||||
name: "bash".to_string(),
|
||||
input: "{\"command\":\"pwd\"}".to_string(),
|
||||
},
|
||||
ContentBlock::ToolUse {
|
||||
id: "tool-2".to_string(),
|
||||
name: "bash".to_string(),
|
||||
input: "{\"command\":\"ls\"}".to_string(),
|
||||
},
|
||||
]),
|
||||
tool_result_message("tool-1"),
|
||||
tool_result_message("tool-2"),
|
||||
];
|
||||
|
||||
let converted = super::convert_messages(&messages);
|
||||
|
||||
assert_eq!(converted.len(), 3, "converted: {converted:?}");
|
||||
let answered = converted[2]
|
||||
.content
|
||||
.iter()
|
||||
.filter_map(|block| match block {
|
||||
InputContentBlock::ToolResult { tool_use_id, .. } => Some(tool_use_id.as_str()),
|
||||
_ => None,
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(answered, vec!["tool-1", "tool-2"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn subagent_merge_requires_both_sides_to_be_tool_results() {
|
||||
let merged = absorb_tool_result_message(
|
||||
vec![InputMessage {
|
||||
role: "user".to_string(),
|
||||
content: vec![InputContentBlock::ToolResult {
|
||||
tool_use_id: "tool-1".to_string(),
|
||||
content: vec![api::ToolResultContentBlock::Text {
|
||||
text: "ok".to_string(),
|
||||
}],
|
||||
is_error: false,
|
||||
}],
|
||||
}],
|
||||
convert_message(&ConversationMessage::assistant(vec![ContentBlock::Text {
|
||||
text: "done".to_string(),
|
||||
}]))
|
||||
.expect("assistant reply converts"),
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
merged.len(),
|
||||
2,
|
||||
"the reply after a tool result must stay its own message: {merged:?}"
|
||||
);
|
||||
assert_eq!(merged[1].role, "assistant");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn subagent_wire_request_pairs_parallel_tool_results() {
|
||||
// The subagent path reaches `convert_messages` only through
|
||||
// `ProviderRuntimeClient::stream`, and that conversion is private, so the
|
||||
// contract has to be checked on the bytes that leave the process: drive the
|
||||
// client against the mock service and assert on the captured body.
|
||||
let _lock = env_guard();
|
||||
// The service must keep serving while this thread blocks inside
|
||||
// `stream()`, so its runtime needs worker threads rather than
|
||||
// `new_current_thread`.
|
||||
let runtime = tokio::runtime::Builder::new_multi_thread()
|
||||
.worker_threads(2)
|
||||
.enable_all()
|
||||
.build()
|
||||
.expect("mock runtime");
|
||||
let server = runtime
|
||||
.block_on(mock_anthropic_service::MockAnthropicService::spawn())
|
||||
.expect("mock service should start");
|
||||
|
||||
// Point the client at the mock: the base URL and both credential variables
|
||||
// are read from the process environment, and this developer shell sets
|
||||
// ANTHROPIC_BASE_URL, so restore whatever was there before.
|
||||
let original_key = std::env::var_os("ANTHROPIC_API_KEY");
|
||||
let original_token = std::env::var_os("ANTHROPIC_AUTH_TOKEN");
|
||||
let original_base = std::env::var_os("ANTHROPIC_BASE_URL");
|
||||
std::env::set_var("ANTHROPIC_API_KEY", "tools-wire-test-key");
|
||||
std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
|
||||
std::env::set_var("ANTHROPIC_BASE_URL", server.base_url());
|
||||
let restore = || {
|
||||
for (key, value) in [
|
||||
("ANTHROPIC_API_KEY", original_key.clone()),
|
||||
("ANTHROPIC_AUTH_TOKEN", original_token.clone()),
|
||||
("ANTHROPIC_BASE_URL", original_base.clone()),
|
||||
] {
|
||||
match value {
|
||||
Some(value) => std::env::set_var(key, value),
|
||||
None => std::env::remove_var(key),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// A turn whose two tool calls already have results: this is exactly the
|
||||
// history `convert_messages` used to split into two wire messages.
|
||||
let messages = vec![
|
||||
ConversationMessage::user_text(format!(
|
||||
"{}multi_tool_turn_roundtrip",
|
||||
mock_anthropic_service::SCENARIO_PREFIX
|
||||
)),
|
||||
ConversationMessage::assistant(vec![
|
||||
ContentBlock::ToolUse {
|
||||
id: "toolu_multi_read".to_string(),
|
||||
name: "read_file".to_string(),
|
||||
input: r#"{"path":"fixture.txt"}"#.to_string(),
|
||||
},
|
||||
ContentBlock::ToolUse {
|
||||
id: "toolu_multi_grep".to_string(),
|
||||
name: "grep_search".to_string(),
|
||||
input: r#"{"pattern":"parity","path":"fixture.txt"}"#.to_string(),
|
||||
},
|
||||
]),
|
||||
ConversationMessage::tool_result(
|
||||
"toolu_multi_read",
|
||||
"read_file",
|
||||
"alpha parity",
|
||||
false,
|
||||
),
|
||||
ConversationMessage::tool_result("toolu_multi_grep", "grep_search", "2", false),
|
||||
];
|
||||
|
||||
let mut client = ProviderRuntimeClient::new_with_fallback_config(
|
||||
"sonnet".to_string(),
|
||||
BTreeSet::from(["read_file".to_string(), "grep_search".to_string()]),
|
||||
&ProviderFallbackConfig::default(),
|
||||
)
|
||||
.expect("provider client");
|
||||
let _ = client.stream(ApiRequest {
|
||||
system_prompt: Vec::new(),
|
||||
messages,
|
||||
});
|
||||
|
||||
let captured = runtime.block_on(server.captured_requests());
|
||||
restore();
|
||||
drop(runtime);
|
||||
let captured = captured
|
||||
.iter()
|
||||
.filter(|request| request.path == "/v1/messages")
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(
|
||||
captured.len(),
|
||||
1,
|
||||
"one message request should leave the client"
|
||||
);
|
||||
let body: serde_json::Value =
|
||||
serde_json::from_str(&captured[0].raw_body).expect("request body is json");
|
||||
let wire = body["messages"].as_array().expect("messages array");
|
||||
|
||||
// The two tool results must share one user message: pairing requires every
|
||||
// tool_use of an assistant turn to be answered in the message right after it.
|
||||
let result_messages = wire
|
||||
.iter()
|
||||
.filter(|message| {
|
||||
message["content"]
|
||||
.as_array()
|
||||
.is_some_and(|blocks| blocks.iter().any(|block| block["type"] == "tool_result"))
|
||||
})
|
||||
.count();
|
||||
assert_eq!(result_messages, 1, "wire body: {body}");
|
||||
let call_messages = wire
|
||||
.iter()
|
||||
.filter(|message| {
|
||||
message["content"]
|
||||
.as_array()
|
||||
.is_some_and(|blocks| blocks.iter().any(|block| block["type"] == "tool_use"))
|
||||
})
|
||||
.count();
|
||||
assert_eq!(call_messages, 1, "wire body: {body}");
|
||||
|
||||
let answered = wire
|
||||
.iter()
|
||||
.flat_map(|message| message["content"].as_array().cloned().unwrap_or_default())
|
||||
.filter(|block| block["type"] == "tool_result")
|
||||
.filter_map(|block| block["tool_use_id"].as_str().map(ToString::to_string))
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(answered, vec!["toolu_multi_read", "toolu_multi_grep"]);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user