979 lines
36 KiB
Rust
979 lines
36 KiB
Rust
//! Anthropic Request Builder
|
||
//!
|
||
//! Converts Open Responses native Item model to Anthropic Messages API format.
|
||
|
||
use std::collections::BTreeSet;
|
||
|
||
use serde::Serialize;
|
||
|
||
use crate::llm_client::{
|
||
Request,
|
||
capability::{CacheStrategy, ModelCapability, ReasoningControl, ReasoningSupport},
|
||
types::{ContentPart, Item, Role, ToolDefinition, parse_tool_arguments},
|
||
};
|
||
|
||
use super::AnthropicScheme;
|
||
|
||
fn is_false(value: &bool) -> bool {
|
||
!*value
|
||
}
|
||
|
||
/// Anthropic API request body
|
||
#[derive(Debug, Serialize)]
|
||
pub(crate) struct AnthropicRequest {
|
||
pub model: String,
|
||
pub max_tokens: u32,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub system: Option<String>,
|
||
pub messages: Vec<AnthropicMessage>,
|
||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||
pub tools: Vec<AnthropicTool>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub temperature: Option<f32>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub top_p: Option<f32>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub top_k: Option<u32>,
|
||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||
pub stop_sequences: Vec<String>,
|
||
pub stream: bool,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub thinking: Option<AnthropicThinking>,
|
||
}
|
||
|
||
/// Anthropic extended thinking 指示。
|
||
#[derive(Debug, Serialize)]
|
||
#[serde(tag = "type", rename_all = "snake_case")]
|
||
pub(crate) enum AnthropicThinking {
|
||
Enabled { budget_tokens: i32 },
|
||
}
|
||
|
||
/// Anthropic message
|
||
#[derive(Debug, Serialize)]
|
||
pub(crate) struct AnthropicMessage {
|
||
pub role: String,
|
||
pub content: AnthropicContent,
|
||
}
|
||
|
||
/// Anthropic content
|
||
#[derive(Debug, Serialize)]
|
||
#[serde(untagged)]
|
||
pub(crate) enum AnthropicContent {
|
||
Text(String),
|
||
Parts(Vec<AnthropicContentPart>),
|
||
}
|
||
|
||
/// `cache_control` marker attached to a content part, signalling that the
|
||
/// prefix up to and including this part should be cached.
|
||
#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]
|
||
#[serde(tag = "type", rename_all = "snake_case")]
|
||
pub(crate) enum CacheControl {
|
||
Ephemeral,
|
||
}
|
||
|
||
/// Anthropic content part
|
||
#[derive(Debug, Serialize)]
|
||
#[serde(tag = "type")]
|
||
pub(crate) enum AnthropicContentPart {
|
||
#[serde(rename = "text")]
|
||
Text {
|
||
text: String,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
cache_control: Option<CacheControl>,
|
||
},
|
||
#[serde(rename = "thinking")]
|
||
Thinking {
|
||
thinking: String,
|
||
signature: String,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
cache_control: Option<CacheControl>,
|
||
},
|
||
#[serde(rename = "redacted_thinking")]
|
||
RedactedThinking {
|
||
/// 暗号化済み reasoning blob。`Item::Reasoning::encrypted_content`
|
||
/// から渡る。
|
||
data: String,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
cache_control: Option<CacheControl>,
|
||
},
|
||
#[serde(rename = "tool_use")]
|
||
ToolUse {
|
||
id: String,
|
||
name: String,
|
||
input: serde_json::Value,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
cache_control: Option<CacheControl>,
|
||
},
|
||
#[serde(rename = "tool_result")]
|
||
ToolResult {
|
||
tool_use_id: String,
|
||
content: String,
|
||
#[serde(default, skip_serializing_if = "is_false")]
|
||
is_error: bool,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
cache_control: Option<CacheControl>,
|
||
},
|
||
}
|
||
|
||
impl AnthropicContentPart {
|
||
fn text(text: String) -> Self {
|
||
Self::Text {
|
||
text,
|
||
cache_control: None,
|
||
}
|
||
}
|
||
|
||
fn thinking(thinking: String, signature: String) -> Self {
|
||
Self::Thinking {
|
||
thinking,
|
||
signature,
|
||
cache_control: None,
|
||
}
|
||
}
|
||
|
||
fn redacted_thinking(data: String) -> Self {
|
||
Self::RedactedThinking {
|
||
data,
|
||
cache_control: None,
|
||
}
|
||
}
|
||
|
||
fn tool_use(id: String, name: String, input: serde_json::Value) -> Self {
|
||
Self::ToolUse {
|
||
id,
|
||
name,
|
||
input,
|
||
cache_control: None,
|
||
}
|
||
}
|
||
|
||
fn tool_result(tool_use_id: String, content: String, is_error: bool) -> Self {
|
||
Self::ToolResult {
|
||
tool_use_id,
|
||
content,
|
||
is_error,
|
||
cache_control: None,
|
||
}
|
||
}
|
||
|
||
fn set_cache_control(&mut self, cc: CacheControl) {
|
||
match self {
|
||
Self::Text { cache_control, .. }
|
||
| Self::Thinking { cache_control, .. }
|
||
| Self::RedactedThinking { cache_control, .. }
|
||
| Self::ToolUse { cache_control, .. }
|
||
| Self::ToolResult { cache_control, .. } => {
|
||
*cache_control = Some(cc);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Anthropic tool definition
|
||
#[derive(Debug, Serialize)]
|
||
pub(crate) struct AnthropicTool {
|
||
pub name: String,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub description: Option<String>,
|
||
pub input_schema: serde_json::Value,
|
||
}
|
||
|
||
impl AnthropicScheme {
|
||
/// Build Anthropic request from Request.
|
||
///
|
||
/// `capability.prompt_caching` が [`CacheStrategy::Auto`] のときは
|
||
/// `cache_control` マーカーを一切挿入しない（Ollama の `/v1/messages`
|
||
/// 流用時など、サーバ側が `cache_control` を受け付けないケース）。
|
||
pub(crate) fn build_request(
|
||
&self,
|
||
model: &str,
|
||
request: &Request,
|
||
capability: &ModelCapability,
|
||
) -> AnthropicRequest {
|
||
let breakpoints = if matches!(capability.prompt_caching, CacheStrategy::Explicit { .. }) {
|
||
compute_breakpoints(&request.items, request.cache_anchor)
|
||
} else {
|
||
BTreeSet::new()
|
||
};
|
||
let messages = self.convert_items_to_messages(&request.items, &breakpoints);
|
||
let tools = request.tools.iter().map(|t| self.convert_tool(t)).collect();
|
||
|
||
// Reasoning の投影: capability が BudgetTokens / Both をサポート
|
||
// していて、request 側で budget_tokens が指定されているときだけ
|
||
// thinking フィールドを付ける。
|
||
let supports_budget_tokens = matches!(
|
||
capability.reasoning,
|
||
Some(ReasoningSupport::BudgetTokens | ReasoningSupport::Both),
|
||
);
|
||
let thinking = request
|
||
.config
|
||
.reasoning
|
||
.as_ref()
|
||
.filter(|_| supports_budget_tokens)
|
||
.and_then(|rc| match rc {
|
||
ReasoningControl::BudgetTokens(budget_tokens) => Some(AnthropicThinking::Enabled {
|
||
budget_tokens: *budget_tokens,
|
||
}),
|
||
ReasoningControl::Effort(_) => None,
|
||
});
|
||
|
||
AnthropicRequest {
|
||
model: model.to_string(),
|
||
max_tokens: request.config.max_tokens.unwrap_or(4096),
|
||
system: request.system_prompt.clone(),
|
||
messages,
|
||
tools,
|
||
temperature: request.config.temperature,
|
||
top_p: request.config.top_p,
|
||
top_k: request.config.top_k,
|
||
stop_sequences: request.config.stop_sequences.clone(),
|
||
stream: true,
|
||
thinking,
|
||
}
|
||
}
|
||
|
||
/// Convert Open Responses Items to Anthropic Messages and attach
|
||
/// `cache_control` markers at each breakpoint item's last content
|
||
/// part.
|
||
///
|
||
/// Anthropic uses a message-based model where:
|
||
/// - User messages have role "user"
|
||
/// - Assistant messages have role "assistant"
|
||
/// - Tool calls are content parts within assistant messages
|
||
/// - Tool results are content parts within user messages
|
||
///
|
||
/// Each non-`Message` item produces exactly one content part, so
|
||
/// "last part for the item" is always well-defined. For breakpoint
|
||
/// `Message` items the output is forced into the array form so a
|
||
/// marker has a part to attach to.
|
||
fn convert_items_to_messages(
|
||
&self,
|
||
items: &[Item],
|
||
breakpoints: &BTreeSet<usize>,
|
||
) -> Vec<AnthropicMessage> {
|
||
let mut messages = Vec::new();
|
||
// Pending parts carry their origin item index so we can record
|
||
// (msg_idx, part_idx) when we flush them into a message.
|
||
let mut pending_assistant: Vec<(usize, AnthropicContentPart)> = Vec::new();
|
||
let mut pending_user: Vec<(usize, AnthropicContentPart)> = Vec::new();
|
||
let mut locations: Vec<Option<(usize, usize)>> = vec![None; items.len()];
|
||
|
||
for (i, item) in items.iter().enumerate() {
|
||
match item {
|
||
Item::Message { role, content, .. } => {
|
||
flush_pending(
|
||
&mut messages,
|
||
&mut pending_assistant,
|
||
"assistant",
|
||
&mut locations,
|
||
);
|
||
flush_pending(&mut messages, &mut pending_user, "user", &mut locations);
|
||
|
||
let anthropic_role = match role {
|
||
Role::User | Role::System => "user",
|
||
Role::Assistant => "assistant",
|
||
};
|
||
|
||
let parts: Vec<AnthropicContentPart> = content
|
||
.iter()
|
||
.map(|p| match p {
|
||
ContentPart::Text { text } => AnthropicContentPart::text(text.clone()),
|
||
ContentPart::Refusal { refusal } => {
|
||
AnthropicContentPart::text(refusal.clone())
|
||
}
|
||
})
|
||
.collect();
|
||
|
||
let force_parts = breakpoints.contains(&i);
|
||
let msg_idx = messages.len();
|
||
|
||
// Preserve the single-text shorthand unless a
|
||
// breakpoint needs a concrete part to live on.
|
||
if parts.len() == 1 && !force_parts {
|
||
if let AnthropicContentPart::Text { text, .. } = &parts[0] {
|
||
messages.push(AnthropicMessage {
|
||
role: anthropic_role.to_string(),
|
||
content: AnthropicContent::Text(text.clone()),
|
||
});
|
||
continue;
|
||
}
|
||
}
|
||
|
||
let last_part_idx = parts.len().saturating_sub(1);
|
||
messages.push(AnthropicMessage {
|
||
role: anthropic_role.to_string(),
|
||
content: AnthropicContent::Parts(parts),
|
||
});
|
||
locations[i] = Some((msg_idx, last_part_idx));
|
||
}
|
||
|
||
Item::ToolCall {
|
||
call_id,
|
||
name,
|
||
arguments,
|
||
..
|
||
} => {
|
||
flush_pending(&mut messages, &mut pending_user, "user", &mut locations);
|
||
// Parse arguments JSON string to Value (defensive:
|
||
// normalize non-object / legacy "null" payloads to
|
||
// `{}` so the Anthropic API accepts it).
|
||
let input = parse_tool_arguments(arguments);
|
||
pending_assistant.push((
|
||
i,
|
||
AnthropicContentPart::tool_use(call_id.clone(), name.clone(), input),
|
||
));
|
||
}
|
||
|
||
Item::ToolResult {
|
||
call_id,
|
||
summary,
|
||
content,
|
||
is_error,
|
||
..
|
||
} => {
|
||
flush_pending(
|
||
&mut messages,
|
||
&mut pending_assistant,
|
||
"assistant",
|
||
&mut locations,
|
||
);
|
||
let text = match content {
|
||
Some(c) => format!("{summary}\n{c}"),
|
||
None => summary.clone(),
|
||
};
|
||
pending_user.push((
|
||
i,
|
||
AnthropicContentPart::tool_result(call_id.clone(), text, *is_error),
|
||
));
|
||
}
|
||
|
||
Item::Reasoning {
|
||
text,
|
||
encrypted_content,
|
||
signature,
|
||
..
|
||
} => {
|
||
flush_pending(&mut messages, &mut pending_user, "user", &mut locations);
|
||
// Anthropic はアシスタントターン中の `thinking` /
|
||
// `redacted_thinking` ブロックを必ず assistant role の
|
||
// content_part として送り返す必要がある。
|
||
//
|
||
// - signature あり: `thinking` content_part を投影
|
||
// - signature 無し + encrypted_content あり:
|
||
// `redacted_thinking` content_part を投影
|
||
// - どちらも無い: 他 scheme（OpenAI 等）から流入した
|
||
// 素の reasoning text。Anthropic に投げる意味も
|
||
// round-trip の根拠も無いので drop。
|
||
if let Some(sig) = signature.clone() {
|
||
pending_assistant
|
||
.push((i, AnthropicContentPart::thinking(text.clone(), sig)));
|
||
} else if let Some(data) = encrypted_content.clone() {
|
||
pending_assistant.push((i, AnthropicContentPart::redacted_thinking(data)));
|
||
}
|
||
// どちらも None なら何も pend せず、本 item は無視。
|
||
}
|
||
}
|
||
}
|
||
|
||
flush_pending(
|
||
&mut messages,
|
||
&mut pending_assistant,
|
||
"assistant",
|
||
&mut locations,
|
||
);
|
||
flush_pending(&mut messages, &mut pending_user, "user", &mut locations);
|
||
|
||
// Apply cache_control markers at each breakpoint item's last part.
|
||
for &bp in breakpoints {
|
||
let Some((msg_idx, part_idx)) = locations.get(bp).copied().flatten() else {
|
||
continue;
|
||
};
|
||
if let AnthropicContent::Parts(parts) = &mut messages[msg_idx].content {
|
||
if let Some(part) = parts.get_mut(part_idx) {
|
||
part.set_cache_control(CacheControl::Ephemeral);
|
||
}
|
||
}
|
||
}
|
||
|
||
messages
|
||
}
|
||
|
||
fn convert_tool(&self, tool: &ToolDefinition) -> AnthropicTool {
|
||
AnthropicTool {
|
||
name: tool.name.clone(),
|
||
description: tool.description.clone(),
|
||
input_schema: tool.input_schema.clone(),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Flush a pending parts buffer into a new message, recording the
|
||
/// emitted `(msg_idx, part_idx)` for each originating item.
|
||
fn flush_pending(
|
||
messages: &mut Vec<AnthropicMessage>,
|
||
pending: &mut Vec<(usize, AnthropicContentPart)>,
|
||
role: &str,
|
||
locations: &mut [Option<(usize, usize)>],
|
||
) {
|
||
if pending.is_empty() {
|
||
return;
|
||
}
|
||
let msg_idx = messages.len();
|
||
let taken: Vec<(usize, AnthropicContentPart)> = std::mem::take(pending);
|
||
let mut parts = Vec::with_capacity(taken.len());
|
||
for (part_idx, (origin, part)) in taken.into_iter().enumerate() {
|
||
locations[origin] = Some((msg_idx, part_idx));
|
||
parts.push(part);
|
||
}
|
||
messages.push(AnthropicMessage {
|
||
role: role.to_string(),
|
||
content: AnthropicContent::Parts(parts),
|
||
});
|
||
}
|
||
|
||
/// Compute the set of item indices that should receive a cache_control
|
||
/// breakpoint:
|
||
///
|
||
/// 1. `cache_anchor` (stable prefix boundary — typically a post-compact
|
||
/// summary at index 0).
|
||
/// 2. The item immediately preceding the most recent `Role::User`
|
||
/// message (i.e. the end of the previous turn). This is the rewind
|
||
/// boundary: if a user re-issues the turn from scratch, the cache up
|
||
/// to here remains valid.
|
||
/// 3. The final item (head of the outgoing request, for the next
|
||
/// request in the same turn to read from).
|
||
///
|
||
/// Overlapping positions are collapsed to a single breakpoint.
|
||
fn compute_breakpoints(items: &[Item], cache_anchor: Option<usize>) -> BTreeSet<usize> {
|
||
let mut bps = BTreeSet::new();
|
||
if items.is_empty() {
|
||
return bps;
|
||
}
|
||
if let Some(anchor) = cache_anchor {
|
||
if anchor < items.len() {
|
||
bps.insert(anchor);
|
||
}
|
||
}
|
||
let last_user = items.iter().rposition(|it| {
|
||
matches!(
|
||
it,
|
||
Item::Message {
|
||
role: Role::User,
|
||
..
|
||
}
|
||
)
|
||
});
|
||
if let Some(i) = last_user {
|
||
if i > 0 {
|
||
bps.insert(i - 1);
|
||
}
|
||
}
|
||
bps.insert(items.len() - 1);
|
||
bps
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::llm_client::capability::{
|
||
CacheStrategy, ReasoningEffort, StructuredOutput, ToolCallingSupport,
|
||
};
|
||
|
||
/// cache_control が有効になる既定の capability。
|
||
fn cap_explicit() -> ModelCapability {
|
||
ModelCapability {
|
||
tool_calling: ToolCallingSupport::Parallel,
|
||
structured_output: StructuredOutput::JsonSchema,
|
||
reasoning: None,
|
||
vision: false,
|
||
prompt_caching: CacheStrategy::Explicit { max_breakpoints: 4 },
|
||
}
|
||
}
|
||
|
||
/// cache_control を送らない capability（Ollama 等）。
|
||
fn cap_auto() -> ModelCapability {
|
||
ModelCapability {
|
||
prompt_caching: CacheStrategy::Auto,
|
||
..cap_explicit()
|
||
}
|
||
}
|
||
|
||
fn cap_budget_reasoning() -> ModelCapability {
|
||
ModelCapability {
|
||
reasoning: Some(ReasoningSupport::BudgetTokens),
|
||
..cap_explicit()
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_build_simple_request() {
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.system("You are a helpful assistant.")
|
||
.user("Hello!");
|
||
|
||
let anthropic_req =
|
||
scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
|
||
assert_eq!(anthropic_req.model, "claude-sonnet-4-20250514");
|
||
assert_eq!(
|
||
anthropic_req.system,
|
||
Some("You are a helpful assistant.".to_string())
|
||
);
|
||
assert_eq!(anthropic_req.messages.len(), 1);
|
||
assert!(anthropic_req.stream);
|
||
}
|
||
|
||
#[test]
|
||
fn test_build_request_with_tool() {
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new().user("What's the weather?").tool(
|
||
ToolDefinition::new("get_weather")
|
||
.description("Get current weather")
|
||
.input_schema(serde_json::json!({
|
||
"type": "object",
|
||
"properties": {
|
||
"location": { "type": "string" }
|
||
},
|
||
"required": ["location"]
|
||
})),
|
||
);
|
||
|
||
let anthropic_req =
|
||
scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
|
||
assert_eq!(anthropic_req.tools.len(), 1);
|
||
assert_eq!(anthropic_req.tools[0].name, "get_weather");
|
||
}
|
||
|
||
#[test]
|
||
fn thinking_budget_projected_when_supported() {
|
||
let scheme = AnthropicScheme::new();
|
||
let mut request = Request::new().user("think");
|
||
request.config.reasoning = Some(ReasoningControl::BudgetTokens(4096));
|
||
|
||
let req = scheme.build_request(
|
||
"claude-sonnet-4-20250514",
|
||
&request,
|
||
&cap_budget_reasoning(),
|
||
);
|
||
let json = serde_json::to_value(&req).unwrap();
|
||
|
||
assert_eq!(json["thinking"]["type"], "enabled");
|
||
assert_eq!(json["thinking"]["budget_tokens"], 4096);
|
||
}
|
||
|
||
#[test]
|
||
fn effort_reasoning_not_projected_to_anthropic() {
|
||
let scheme = AnthropicScheme::new();
|
||
let mut request = Request::new().user("think");
|
||
request.config.reasoning = Some(ReasoningControl::Effort(ReasoningEffort::High));
|
||
|
||
let req = scheme.build_request(
|
||
"claude-sonnet-4-20250514",
|
||
&request,
|
||
&cap_budget_reasoning(),
|
||
);
|
||
|
||
assert!(req.thinking.is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn test_tool_call_and_result() {
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.user("What's the weather?")
|
||
.item(Item::tool_call(
|
||
"call_123",
|
||
"get_weather",
|
||
r#"{"city":"Tokyo"}"#,
|
||
))
|
||
.item(Item::tool_result("call_123", "Sunny, 25°C"));
|
||
|
||
let anthropic_req =
|
||
scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
|
||
assert_eq!(anthropic_req.messages.len(), 3);
|
||
assert_eq!(anthropic_req.messages[0].role, "user");
|
||
assert_eq!(anthropic_req.messages[1].role, "assistant");
|
||
assert_eq!(anthropic_req.messages[2].role, "user");
|
||
}
|
||
|
||
/// Pull out the `cache_control` field from a part regardless of variant.
|
||
fn part_cache_control(part: &AnthropicContentPart) -> Option<CacheControl> {
|
||
match part {
|
||
AnthropicContentPart::Text { cache_control, .. }
|
||
| AnthropicContentPart::Thinking { cache_control, .. }
|
||
| AnthropicContentPart::RedactedThinking { cache_control, .. }
|
||
| AnthropicContentPart::ToolUse { cache_control, .. }
|
||
| AnthropicContentPart::ToolResult { cache_control, .. } => *cache_control,
|
||
}
|
||
}
|
||
|
||
/// All `(msg_idx, part_idx, cache_control)` triples whose `cache_control`
|
||
/// is set, in iteration order over the output.
|
||
fn breakpoint_positions(req: &AnthropicRequest) -> Vec<(usize, usize, CacheControl)> {
|
||
let mut out = Vec::new();
|
||
for (mi, msg) in req.messages.iter().enumerate() {
|
||
if let AnthropicContent::Parts(parts) = &msg.content {
|
||
for (pi, part) in parts.iter().enumerate() {
|
||
if let Some(cc) = part_cache_control(part) {
|
||
out.push((mi, pi, cc));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// Convenience: a turn that ends with one assistant text, one tool
|
||
/// call/result pair, and a final assistant text. Produced at
|
||
/// `history[head..]` indices shown alongside, so tests can reason
|
||
/// about breakpoint positions.
|
||
fn completed_turn() -> Vec<Item> {
|
||
vec![
|
||
Item::user_message("hello"), // 0
|
||
Item::assistant_message("hi"), // 1
|
||
Item::tool_call("c1", "tool_a", "{}"), // 2
|
||
Item::tool_result("c1", "ok"), // 3
|
||
Item::assistant_message("done"), // 4
|
||
]
|
||
}
|
||
|
||
#[test]
|
||
fn three_breakpoints_when_compact_plus_prior_turn() {
|
||
let scheme = AnthropicScheme::new();
|
||
let mut items = vec![Item::system_message("[Compacted context summary]\n\nprior")];
|
||
items.extend(completed_turn()); // now indices 1..=5
|
||
items.push(Item::user_message("next turn"));
|
||
// anchor=0, last user idx=6 → turn_end=5, head=6.
|
||
let mut request = Request::new().items(items);
|
||
request.cache_anchor = Some(0);
|
||
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let bps = breakpoint_positions(&req);
|
||
assert_eq!(bps.len(), 3, "expected 3 breakpoints, got {:?}", bps);
|
||
for (_, _, cc) in bps {
|
||
assert_eq!(cc, CacheControl::Ephemeral);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn two_breakpoints_without_compaction() {
|
||
let scheme = AnthropicScheme::new();
|
||
let mut items = completed_turn();
|
||
items.push(Item::user_message("next turn")); // index 5 = latest user
|
||
// cache_anchor=None, turn_end=4, head=5.
|
||
let request = Request::new().items(items);
|
||
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let bps = breakpoint_positions(&req);
|
||
assert_eq!(bps.len(), 2, "expected 2 breakpoints, got {:?}", bps);
|
||
}
|
||
|
||
#[test]
|
||
fn single_breakpoint_when_only_first_user_message() {
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new().user("first ever turn");
|
||
// latest user at 0 → no turn_end; head=0; no anchor. Collapse → 1.
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let bps = breakpoint_positions(&req);
|
||
assert_eq!(bps.len(), 1, "expected 1 breakpoint, got {:?}", bps);
|
||
}
|
||
|
||
#[test]
|
||
fn overlap_collapses_anchor_and_turn_end() {
|
||
// items = [compact_summary(0, Role::System), user(1)]
|
||
// anchor=0, latest user=1 → turn_end=0, head=1. Anchor∩turn_end at 0.
|
||
let scheme = AnthropicScheme::new();
|
||
let mut request = Request::new().items(vec![
|
||
Item::system_message("[Compacted context summary]\n\nprior"),
|
||
Item::user_message("fresh user"),
|
||
]);
|
||
request.cache_anchor = Some(0);
|
||
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let bps = breakpoint_positions(&req);
|
||
assert_eq!(bps.len(), 2, "expected collapse to 2, got {:?}", bps);
|
||
}
|
||
|
||
#[test]
|
||
fn breakpoint_on_tool_result_head() {
|
||
// Mid-turn second call: items end with a tool_result. Head must
|
||
// land on the ToolResult part.
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.user("run it")
|
||
.item(Item::tool_call("c1", "t", "{}"))
|
||
.item(Item::tool_result("c1", "result"));
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let bps = breakpoint_positions(&req);
|
||
assert_eq!(bps.len(), 1);
|
||
let (mi, pi, _) = bps[0];
|
||
let part = match &req.messages[mi].content {
|
||
AnthropicContent::Parts(parts) => &parts[pi],
|
||
_ => panic!("expected Parts for breakpoint-bearing message"),
|
||
};
|
||
assert!(
|
||
matches!(part, AnthropicContentPart::ToolResult { .. }),
|
||
"expected ToolResult, got {:?}",
|
||
part,
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn single_text_message_uses_text_shorthand_without_breakpoint() {
|
||
// Non-breakpoint single-text messages stay on the text shorthand
|
||
// so we don't bloat requests with wrapper arrays. Here the Head
|
||
// lands on items[1], leaving items[0] without a marker.
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new().user("hello").assistant("hi there");
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
assert!(
|
||
matches!(req.messages[0].content, AnthropicContent::Text(_)),
|
||
"non-breakpoint single-text message should use text shorthand",
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn single_text_message_is_forced_to_parts_when_breakpoint() {
|
||
// A breakpoint on a single-text message must be emitted in the
|
||
// array form so cache_control has a part to attach to.
|
||
let scheme = AnthropicScheme::new();
|
||
let mut request = Request::new().user("hello");
|
||
request.cache_anchor = Some(0);
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
match &req.messages[0].content {
|
||
AnthropicContent::Parts(parts) => {
|
||
assert_eq!(parts.len(), 1);
|
||
assert_eq!(part_cache_control(&parts[0]), Some(CacheControl::Ephemeral));
|
||
}
|
||
AnthropicContent::Text(_) => panic!("breakpoint item should use Parts form"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn serialized_json_shape_matches_anthropic_spec() {
|
||
// Single-sentence smoke test against the exact JSON key shape
|
||
// Anthropic expects for cache_control.
|
||
let scheme = AnthropicScheme::new();
|
||
let mut request = Request::new().user("hello");
|
||
request.cache_anchor = Some(0);
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let json = serde_json::to_value(&req).unwrap();
|
||
let part = &json["messages"][0]["content"][0];
|
||
assert_eq!(part["type"], "text");
|
||
assert_eq!(part["text"], "hello");
|
||
assert_eq!(part["cache_control"]["type"], "ephemeral");
|
||
}
|
||
|
||
#[test]
|
||
fn cache_anchor_out_of_range_is_ignored() {
|
||
// Defensive: if a caller passes a stale anchor beyond items.len(),
|
||
// we drop it silently rather than panicking.
|
||
let scheme = AnthropicScheme::new();
|
||
let mut request = Request::new().user("one");
|
||
request.cache_anchor = Some(99);
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
// Only the Head breakpoint survives.
|
||
let bps = breakpoint_positions(&req);
|
||
assert_eq!(bps.len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn empty_items_produce_no_breakpoints() {
|
||
let scheme = AnthropicScheme::new();
|
||
let req =
|
||
scheme.build_request("claude-sonnet-4-20250514", &Request::new(), &cap_explicit());
|
||
assert!(req.messages.is_empty());
|
||
assert!(breakpoint_positions(&req).is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn cache_auto_does_not_add_cache_control() {
|
||
// Ollama のように `CacheStrategy::Auto` のときは cache_control
|
||
// マーカーを一切付けない。breakpoint 計算も走らないこと。
|
||
let scheme = AnthropicScheme::new();
|
||
let mut request = Request::new().user("hello");
|
||
request.cache_anchor = Some(0);
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_auto());
|
||
assert!(breakpoint_positions(&req).is_empty());
|
||
}
|
||
|
||
fn collect_assistant_thinking_parts(req: &AnthropicRequest) -> Vec<&AnthropicContentPart> {
|
||
let mut out = Vec::new();
|
||
for msg in &req.messages {
|
||
if msg.role != "assistant" {
|
||
continue;
|
||
}
|
||
if let AnthropicContent::Parts(parts) = &msg.content {
|
||
for part in parts {
|
||
if matches!(
|
||
part,
|
||
AnthropicContentPart::Thinking { .. }
|
||
| AnthropicContentPart::RedactedThinking { .. }
|
||
) {
|
||
out.push(part);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
#[test]
|
||
fn reasoning_with_signature_projects_thinking_part() {
|
||
// Item::Reasoning に signature があれば assistant role の
|
||
// `thinking` content_part として送る。
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.user("hi")
|
||
.item(Item::reasoning("step-by-step").with_signature("SIG-A"))
|
||
.item(Item::assistant_message("done"));
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let thinking_parts = collect_assistant_thinking_parts(&req);
|
||
assert_eq!(thinking_parts.len(), 1);
|
||
match thinking_parts[0] {
|
||
AnthropicContentPart::Thinking {
|
||
thinking,
|
||
signature,
|
||
..
|
||
} => {
|
||
assert_eq!(thinking, "step-by-step");
|
||
assert_eq!(signature, "SIG-A");
|
||
}
|
||
other => panic!("expected Thinking part, got {other:?}"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn reasoning_with_only_encrypted_content_projects_redacted_thinking() {
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.user("hi")
|
||
.item(Item::reasoning("").with_encrypted_content("opaque"))
|
||
.item(Item::assistant_message("done"));
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let parts = collect_assistant_thinking_parts(&req);
|
||
assert_eq!(parts.len(), 1);
|
||
match parts[0] {
|
||
AnthropicContentPart::RedactedThinking { data, .. } => {
|
||
assert_eq!(data, "opaque");
|
||
}
|
||
other => panic!("expected RedactedThinking, got {other:?}"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn reasoning_without_signature_or_encrypted_is_dropped() {
|
||
// 他 scheme から流入した素の reasoning は Anthropic に投げない。
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.user("hi")
|
||
.item(Item::reasoning("plain text"))
|
||
.item(Item::assistant_message("done"));
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
// thinking part は 1 つも乗らない
|
||
assert!(collect_assistant_thinking_parts(&req).is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn thinking_part_lands_in_assistant_role_message() {
|
||
// wire 構造の position 検証: thinking part は assistant role の
|
||
// message 配列に並ぶ（user role には絶対に入らない）。
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.user("question?")
|
||
.item(Item::reasoning("thinking inside").with_signature("SIG-A"))
|
||
.item(Item::tool_call("c1", "tool_a", "{}"))
|
||
.item(Item::tool_result("c1", "result"))
|
||
.user("follow up");
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
|
||
// 全 thinking part が assistant role の message に存在すること
|
||
let mut thinking_msg_indices = Vec::new();
|
||
for (i, msg) in req.messages.iter().enumerate() {
|
||
if let AnthropicContent::Parts(parts) = &msg.content {
|
||
if parts
|
||
.iter()
|
||
.any(|p| matches!(p, AnthropicContentPart::Thinking { .. }))
|
||
{
|
||
assert_eq!(
|
||
msg.role, "assistant",
|
||
"thinking part must be in assistant role, got {} at msg {}",
|
||
msg.role, i,
|
||
);
|
||
thinking_msg_indices.push(i);
|
||
}
|
||
}
|
||
}
|
||
assert!(
|
||
!thinking_msg_indices.is_empty(),
|
||
"expected at least one thinking part in messages: {:?}",
|
||
req.messages,
|
||
);
|
||
|
||
// thinking part を含む assistant message は、それに続く tool_use を含む
|
||
// assistant message より前 (= 先頭側) に位置すること
|
||
// (Anthropic 仕様: 同一論理ターン内で thinking → tool_use の順)
|
||
let mut tool_use_msg_indices = Vec::new();
|
||
for (i, msg) in req.messages.iter().enumerate() {
|
||
if let AnthropicContent::Parts(parts) = &msg.content {
|
||
if parts
|
||
.iter()
|
||
.any(|p| matches!(p, AnthropicContentPart::ToolUse { .. }))
|
||
{
|
||
tool_use_msg_indices.push(i);
|
||
}
|
||
}
|
||
}
|
||
assert!(!tool_use_msg_indices.is_empty(), "expected tool_use part");
|
||
let first_thinking = thinking_msg_indices[0];
|
||
let first_tool_use = tool_use_msg_indices[0];
|
||
assert!(
|
||
first_thinking <= first_tool_use,
|
||
"thinking msg ({}) must precede tool_use msg ({})",
|
||
first_thinking,
|
||
first_tool_use,
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn redacted_thinking_part_lands_in_assistant_role_message() {
|
||
// RedactedThinking も同様に assistant role に置かれること。
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.user("ask")
|
||
.item(Item::reasoning("").with_encrypted_content("opaque"))
|
||
.item(Item::tool_call("c1", "tool_a", "{}"))
|
||
.item(Item::tool_result("c1", "ok"));
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
for msg in &req.messages {
|
||
if let AnthropicContent::Parts(parts) = &msg.content {
|
||
for part in parts {
|
||
if matches!(part, AnthropicContentPart::RedactedThinking { .. }) {
|
||
assert_eq!(msg.role, "assistant");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn tool_definitions_carry_no_cache_control() {
|
||
// Tool JSON schema must serialise unchanged — no sneak-in of
|
||
// cache_control at the tools-array level.
|
||
let scheme = AnthropicScheme::new();
|
||
let request = Request::new()
|
||
.user("hello")
|
||
.tool(ToolDefinition::new("noop").input_schema(serde_json::json!({
|
||
"type": "object",
|
||
"properties": {}
|
||
})));
|
||
let req = scheme.build_request("claude-sonnet-4-20250514", &request, &cap_explicit());
|
||
let json = serde_json::to_value(&req).unwrap();
|
||
let tool = &json["tools"][0];
|
||
assert!(tool.get("cache_control").is_none());
|
||
}
|
||
}
|