Skip to content
Python
22.6 KB
Raw Blame
//! Claude Messages adapter over the runtime's canonical items. No execution or retries.
use crate::{
    model::{validate_output, Progress},
    provider::{Completion, Error, Failure, Usage},
};
use futures_util::StreamExt;
use serde_json::{json, Value};
use std::collections::{BTreeMap, BTreeSet};
use tokio::sync::mpsc;

/// Explicit generation configuration; display is controlled separately per turn.
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]
pub enum Thinking {
    Disabled,
    Adaptive,
    Enabled {
        #[serde(rename = "budgetTokens")]
        budget_tokens: u32,
    },
}
impl Thinking {
    pub fn validate(&self) -> anyhow::Result<()> {
        if let Self::Enabled { budget_tokens } = self {
            anyhow::ensure!(
                (1024..=1_000_000).contains(budget_tokens),
                "Thinking budget must be between 1024 and 1000000 tokens"
            );
        }
        Ok(())
    }
    /// Output limits take precedence over manual thinking allowances. Return
    /// None below the manual minimum rather than sending an invalid request or
    /// forcing `disabled`, which some adaptive-only models reject.
    pub fn request(&self, max_tokens: usize) -> Result<Option<Value>, Error> {
        self.validate().map_err(|_| config())?;
        Ok(Some(match self {
            Self::Disabled => json!({"type":"disabled"}),
            Self::Adaptive => json!({"type":"adaptive"}),
            Self::Enabled { budget_tokens } => {
                let budget_tokens = (*budget_tokens as usize).min(max_tokens.saturating_sub(1));
                if budget_tokens < 1024 {
                    return Ok(None);
                }
                json!({"type":"enabled","budget_tokens":budget_tokens})
            }
        }))
    }
}

fn invalid() -> Error {
    Error::new(Failure::InvalidResponse).with_code("invalid_anthropic_message")
}
fn config() -> Error {
    Error::new(Failure::Configuration).with_code("invalid_anthropic_request")
}

fn append(messages: &mut Vec<Value>, role: &str, blocks: Vec<Value>) {
    if blocks.is_empty() {
        return;
    }
    if let Some(last) = messages.last_mut().filter(|m| m["role"] == role) {
        last["content"].as_array_mut().unwrap().extend(blocks);
    } else {
        messages.push(json!({"role":role,"content":blocks}));
    }
}

fn content(value: &Value) -> Result<Vec<Value>, Error> {
    if let Some(s) = value.as_str() {
        return Ok(vec![json!({"type":"text","text":s})]);
    }
    value
        .as_array()
        .ok_or_else(config)?
        .iter()
        .map(|v| match v["type"].as_str() {
            Some("text" | "input_text" | "output_text") => {
                Ok(json!({"type":"text","text":v["text"].as_str().ok_or_else(config)?}))
            }
            Some("input_file") => {let url=v["file_data"].as_str().ok_or_else(config)?;let data=url.strip_prefix("data:application/pdf;base64,").ok_or_else(config)?;Ok(json!({"type":"document","title":v["filename"],"source":{"type":"base64","media_type":"application/pdf","data":data}}))}
            Some("input_image") => {
                let url = v["image_url"].as_str().ok_or_else(config)?;
                let (header, data) = url.split_once(",").ok_or_else(config)?;
                let mime = header
                    .strip_prefix("data:")
                    .and_then(|s| s.strip_suffix(";base64"))
                    .ok_or_else(config)?;
                if !["image/png", "image/jpeg", "image/gif", "image/webp"].contains(&mime) {
                    return Err(config());
                }
                Ok(json!({"type":"image","source":{"type":"base64","media_type":mime,"data":data}}))
            }
            _ => Err(config()),
        })
        .collect()
}

pub fn body(
    model: &str,
    instructions: &str,
    history: &[Value],
    tools: &[Value],
    max_tokens: usize,
    format: Option<&Value>,
) -> Result<Value, Error> {
    let mut messages: Vec<Value> = vec![];
    let mut pending = BTreeSet::new();
    let mut calls = BTreeSet::new();
    for item in history {
        match item["type"].as_str() {
            Some("reasoning") => {
                // Provider-private blocks never cross provider boundaries.
                if item["provider"] != "anthropic"
                    || (!pending.is_empty()
                        && messages.last().is_none_or(|m| m["role"] != "assistant"))
                {
                    return Err(config());
                }
                append(&mut messages, "assistant", vec![item["block"].clone()]);
            }
            Some("function_call") => {
                let id = item["call_id"].as_str().ok_or_else(config)?;
                if !calls.insert(id.to_owned()) {
                    return Err(config());
                }
                pending.insert(id.to_owned());
                let input: Value =
                    serde_json::from_str(item["arguments"].as_str().ok_or_else(config)?)
                        .map_err(|_| config())?;
                if !input.is_object() {
                    return Err(config());
                }
                append(
                    &mut messages,
                    "assistant",
                    vec![
                        json!({"type":"tool_use","id":id,"name":item["name"].as_str().ok_or_else(config)?,"input":input}),
                    ],
                );
            }
            Some("function_call_output") => {
                let id = item["call_id"].as_str().ok_or_else(config)?;
                if !pending.remove(id) {
                    return Err(config());
                }
                let result = &item["output"];
                let is_error = result
                    .as_str()
                    .and_then(|s| serde_json::from_str::<Value>(s).ok())
                    .is_some_and(|v| v["isError"] == true || v["denied"] == true);
                append(
                    &mut messages,
                    "user",
                    vec![
                        json!({"type":"tool_result","tool_use_id":id,"content":content(result)?,"is_error":is_error}),
                    ],
                );
            }
            Some("message") | None => {
                let role = item["role"].as_str().ok_or_else(config)?;
                if !pending.is_empty()
                    && (role != "assistant"
                        || messages.last().is_none_or(|m| m["role"] != "assistant"))
                {
                    return Err(config());
                }
                if !["assistant", "user"].contains(&role) {
                    return Err(config());
                }
                append(&mut messages, role, content(&item["content"])?);
            }
            _ => return Err(config()),
        }
    }
    if !pending.is_empty() || messages.first().is_none_or(|m| m["role"] != "user") {
        return Err(config());
    }
    let definitions = tools.iter().map(|t| {
        if t["type"] != "function" || !t["parameters"].is_object() { return Err(config()); }
        Ok(json!({"name":t["name"].as_str().ok_or_else(config)?,"description":t["description"].as_str().unwrap_or(""),"input_schema":t["parameters"]}))
    }).collect::<Result<Vec<_>,Error>>()?;
    // Automatic caching moves the breakpoint with the growing conversation.
    // The provider decides eligibility/minimum prefix length; a request does
    // not imply a cache hit. Applications can explicitly opt out per provider.
    let mut body = json!({"model":model,"system":instructions,"messages":messages,"max_tokens":max_tokens,"stream":true,"cache_control":{"type":"ephemeral"}});
    if !definitions.is_empty() {
        body["tools"] = json!(definitions);
        body["tool_choice"] = json!({"type":"auto","disable_parallel_tool_use":true});
    }
    if let Some(f) = format {
        if f["type"] != "json_schema" || !f["schema"].is_object() {
            return Err(config());
        }
        body["output_config"] = json!({"format":{"type":"json_schema","schema":f["schema"]}});
    }
    Ok(body)
}

struct Block {
    value: Value,
    input: String,
    closed: bool,
}
#[derive(Default)]
pub struct Decoder {
    started: bool,
    stopped: bool,
    failed: bool,
    reason: Option<String>,
    blocks: BTreeMap<u64, Block>,
    usage: Usage,
    output_known: bool,
    input_known: bool,
    reasoning: Option<crate::provider::ReasoningDelta>,
}
impl Decoder {
    pub fn take_reasoning(&mut self) -> Option<crate::provider::ReasoningDelta> {
        self.reasoning.take()
    }
    fn usage_report(&self) -> Option<crate::telemetry::TokenUsage> {
        self.input_known.then(|| {
            let mut u = self.usage.reported();
            if !self.output_known {
                u.output = None;
            }
            u
        })
    }
    fn output_started(&self) -> bool {
        self.blocks.values().any(|b| {
            b.value["type"] == "tool_use"
                || b.value["type"] == "text"
                    && b.value["text"].as_str().is_some_and(|s| !s.is_empty())
        })
    }
    pub fn event(&mut self, event: &Value) -> Result<Option<String>, Error> {
        let result = self.accept(event);
        if result.is_err() {
            self.failed = true;
        }
        result
    }
    fn accept(&mut self, e: &Value) -> Result<Option<String>, Error> {
        if self.failed || self.stopped {
            return Err(invalid());
        }
        match e["type"].as_str() {
            Some("ping") => {}
            Some("error") => return Err(Error::new(classify(0, &e["error"]))),
            Some("message_start") => {
                if self.started
                    || e["message"]["role"] != "assistant"
                    || e["message"]["content"]
                        .as_array()
                        .is_none_or(|v| !v.is_empty())
                {
                    return Err(invalid());
                }
                self.started = true;
                let u = &e["message"]["usage"];
                let input = u["input_tokens"].as_u64().ok_or_else(invalid)?;
                let cache_read = u["cache_read_input_tokens"].as_u64().unwrap_or(0);
                let cache_write = u["cache_creation_input_tokens"].as_u64().unwrap_or(0);
                self.usage.input_tokens = input
                    .checked_add(cache_read)
                    .and_then(|n| n.checked_add(cache_write))
                    .ok_or_else(invalid)?;
                self.input_known = true;
                if let Some(output) = u["output_tokens"].as_u64() {
                    self.usage.output_tokens = output;
                    self.output_known = true;
                }
                self.usage.cached_input_tokens = cache_read;
                self.usage.cache_read_input_tokens = u["cache_read_input_tokens"].as_u64();
                self.usage.cache_write_input_tokens = u["cache_creation_input_tokens"].as_u64();
            }
            Some("content_block_start") => {
                if !self.started || self.reason.is_some() || self.blocks.values().any(|b| !b.closed)
                {
                    return Err(invalid());
                }
                let index = e["index"].as_u64().ok_or_else(invalid)?;
                if index != self.blocks.len() as u64 || index >= 64 {
                    return Err(invalid());
                }
                let v = e["content_block"].clone();
                match v["type"].as_str() {
                    Some("text") if v["text"].is_string() => {}
                    Some("tool_use")
                        if v["id"].is_string()
                            && v["name"].is_string()
                            && v["input"].is_object() => {}
                    Some("thinking") if v["thinking"].is_string() => {}
                    Some("redacted_thinking") if v["data"].is_string() => {}
                    _ => return Err(invalid()),
                }
                self.blocks.insert(
                    index,
                    Block {
                        value: v,
                        input: String::new(),
                        closed: false,
                    },
                );
            }
            Some("content_block_delta") => {
                let block = self
                    .blocks
                    .get_mut(&e["index"].as_u64().ok_or_else(invalid)?)
                    .ok_or_else(invalid)?;
                if block.closed || self.reason.is_some() {
                    return Err(invalid());
                }
                let d = &e["delta"];
                let (field, fragment) = match (block.value["type"].as_str(), d["type"].as_str()) {
                    (Some("text"), Some("text_delta")) => {
                        ("text", d["text"].as_str().ok_or_else(invalid)?)
                    }
                    (Some("tool_use"), Some("input_json_delta")) => {
                        ("input", d["partial_json"].as_str().ok_or_else(invalid)?)
                    }
                    (Some("thinking"), Some("thinking_delta")) => {
                        ("thinking", d["thinking"].as_str().ok_or_else(invalid)?)
                    }
                    (Some("thinking"), Some("signature_delta")) => {
                        ("signature", d["signature"].as_str().ok_or_else(invalid)?)
                    }
                    _ => return Err(invalid()),
                };
                if field == "input" {
                    block.input.push_str(fragment);
                } else {
                    let mut value = block.value[field].as_str().unwrap_or("").to_owned();
                    value.push_str(fragment);
                    block.value[field] = json!(value);
                }
                if block.input.len() + block.value.to_string().len() > 512000 {
                    return Err(invalid());
                }
                if field == "text" {
                    return Ok(Some(fragment.into()));
                }
                if field == "thinking" {
                    self.reasoning = Some(crate::provider::ReasoningDelta {
                        kind: crate::provider::ReasoningKind::Thinking,
                        text: fragment.into(),
                        block_index: e["index"].as_u64().ok_or_else(invalid)?,
                    });
                }
            }
            Some("content_block_stop") => {
                let block = self
                    .blocks
                    .get_mut(&e["index"].as_u64().ok_or_else(invalid)?)
                    .ok_or_else(invalid)?;
                if block.closed {
                    return Err(invalid());
                }
                // A closed block can still be incomplete when the message hit
                // its token limit. Validate content only after the message-level
                // outcome; otherwise truncation is misreported as invalid JSON
                // (or a missing thinking signature) and cannot be recovered.
                block.closed = true;
            }
            Some("message_delta") => {
                if !self.started || self.reason.is_some() {
                    return Err(invalid());
                }
                self.usage.output_tokens =
                    e["usage"]["output_tokens"].as_u64().ok_or_else(invalid)?;
                self.output_known = true;
                let reason = e["delta"]["stop_reason"].as_str().ok_or_else(invalid)?;
                match reason {
                    "end_turn" | "tool_use" => {
                        if self.blocks.values().any(|b| !b.closed) {
                            return Err(invalid());
                        }
                        self.reason = Some(reason.into());
                    }
                    "refusal" => return Err(Error::new(Failure::SafetyBlocked)),
                    "max_tokens" | "model_context_window_exceeded" => {
                        // A token-limited tool stream may omit content_block_stop.
                        // Its unfinished blocks are discarded, never completed.
                        return Err(Error::new(Failure::Truncated));
                    }
                    _ => return Err(invalid()),
                }
            }
            Some("message_stop") => {
                if !self.started || self.reason.is_none() || self.blocks.values().any(|b| !b.closed)
                {
                    return Err(invalid());
                }
                self.stopped = true;
            }
            _ => return Err(invalid()),
        }
        Ok(None)
    }
    pub fn finish(self) -> Result<Completion, Error> {
        if self.failed {
            return Err(invalid());
        }
        if !self.stopped {
            return Err(Error::new(Failure::IncompleteStream));
        }
        let mut output = vec![];
        let mut tool = false;
        for b in self.blocks.into_values() {
            let mut v = b.value;
            if v["type"] == "tool_use" && !b.input.is_empty() {
                v["input"] = serde_json::from_str(&b.input).map_err(|_| invalid())?;
                if !v["input"].is_object() {
                    return Err(invalid());
                }
            }
            if v["type"] == "thinking" && v["signature"].as_str().is_none_or(str::is_empty) {
                return Err(invalid());
            }
            match v["type"].as_str() {
                Some("text") => output.push(json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":v["text"]}]})),
                Some("tool_use") => {
                    tool = true;
                    output.push(json!({"type":"function_call","call_id":v["id"],"name":v["name"],"arguments":v["input"].to_string()}));
                }
                Some("thinking" | "redacted_thinking") => output.push(json!({"type":"reasoning","provider":"anthropic","block":v})),
                _ => return Err(invalid()),
            }
        }
        if output.is_empty()
            || tool != (self.reason.as_deref() == Some("tool_use"))
            || validate_output(&output).is_err()
        {
            return Err(invalid());
        }
        Ok(Completion {
            output,
            usage: Some(self.usage),
        })
    }
}

pub fn classify(status: u16, error: &Value) -> Failure {
    match error["type"].as_str().unwrap_or("") {
        "authentication_error" | "permission_error" => Failure::Authentication,
        "rate_limit_error" => Failure::RateLimit,
        "overloaded_error" | "api_error" => Failure::Transient,
        "invalid_request_error"
            if error["message"]
                .as_str()
                .is_some_and(|s| s.to_ascii_lowercase().contains("prompt is too long")) =>
        {
            Failure::ContextOverflow
        }
        _ if status == 529 => Failure::Transient,
        _ => crate::provider::classify(status, ""),
    }
}

pub async fn request(
    client: &reqwest::Client,
    url: &str,
    key: &str,
    body: Value,
    tx: mpsc::Sender<Progress>,
) -> Result<(), Error> {
    let response = client
        .post(url)
        .header("x-api-key", key)
        .header("anthropic-version", "2023-06-01")
        .json(&body)
        .send()
        .await
        .map_err(|_| Error::new(Failure::Transport))?;
    let status = response.status().as_u16();
    let request_id = crate::provider::request_id(response.headers(), key);
    let retry_after = response
        .headers()
        .get("retry-after")
        .and_then(|v| v.to_str().ok())
        .and_then(|v| v.parse().ok());
    let mut stream = response.bytes_stream();
    if !(200..300).contains(&status) {
        let mut bytes = vec![];
        while let Some(chunk) = stream.next().await {
            let chunk = chunk.map_err(|_| Error {
                kind: classify(status, &Value::Null),
                retry_after,
                http_status: Some(status),
                request_id: request_id.clone(),
                api: Some(crate::model_api::Api::Anthropic),
                code: Some("http_error_body_unavailable"),
            })?;
            if bytes.len() + chunk.len() > 16384 {
                break;
            }
            bytes.extend_from_slice(&chunk);
        }
        let error: Value = serde_json::from_slice(&bytes).unwrap_or(Value::Null);
        return Err(Error {
            http_status: Some(status),
            request_id,
            api: Some(crate::model_api::Api::Anthropic),
            code: crate::provider::upstream_code(&error["error"]),
            kind: classify(status, &error["error"]),
            retry_after,
        });
    }
    let mut decoder = Decoder::default();
    let mut buffer = vec![];
    let mut total = 0;
    let mut previous_usage = None;
    let mut first_sent = false;
    while let Some(chunk) = stream.next().await {
        let chunk = chunk.map_err(|_| Error::new(Failure::Transport))?;
        total += chunk.len();
        if total > 8 * 1024 * 1024 {
            return Err(invalid());
        }
        buffer.extend_from_slice(&chunk);
        while let Some(index) = buffer.iter().position(|b| *b == b'\n') {
            let line: Vec<_> = buffer.drain(..=index).collect();
            let line = std::str::from_utf8(&line).map_err(|_| invalid())?.trim();
            if let Some(data) = line.strip_prefix("data:") {
                let event: Value = serde_json::from_str(data).map_err(|_| invalid())?;
                let decoded = decoder.event(&event);
                if let Some(usage) = decoder
                    .usage_report()
                    .filter(|u| u.present() && Some(*u) != previous_usage)
                {
                    tx.send(Progress::Usage(usage))
                        .await
                        .map_err(|_| Error::new(Failure::Transport))?;
                    previous_usage = Some(usage);
                }
                let decoded = decoded?;
                if let Some(delta) = decoder.take_reasoning() {
                    tx.send(Progress::Reasoning(delta))
                        .await
                        .map_err(|_| Error::new(Failure::Transport))?;
                }
                if !first_sent && decoder.output_started() {
                    tx.send(Progress::OutputStarted)
                        .await
                        .map_err(|_| Error::new(Failure::Transport))?;
                    first_sent = true;
                }
                if let Some(text) = decoded {
                    tx.send(Progress::Delta(text))
                        .await
                        .map_err(|_| Error::new(Failure::Transport))?;
                }
            }
        }
    }
    if !buffer.iter().all(u8::is_ascii_whitespace) {
        return Err(invalid());
    }
    tx.send(Progress::Complete(decoder.finish()?))
        .await
        .map_err(|_| Error::new(Failure::Transport))?;
    Ok(())
}