//! Anthropic Messages protocol component. #![expect(missing_docs, reason = "wit-bindgen generates the world surface")] #![expect(clippy::pedantic, reason = "wit-bindgen generates the world surface")] wit_bindgen::generate!({ path: "../../wit/smith-plugin.wit", world: "plugin-world" }); use exports::smith::plugin::plugin::{Guest as PluginGuest, ToolDeclaration}; use exports::smith::plugin::provider::{ CatalogSnapshot, DecodeStep, Guest as ProviderGuest, MessageBlock, MessageRole, ProviderRequest, ProviderSettings, RequestTemplate, SettingsProvenance, StopReason, StreamEvent, ToolUse, Usage, }; use exports::smith::plugin::registration::{ CredentialSource, Guest as RegistrationGuest, ProtocolBinding, ProviderContribution, Registrations, }; use serde_json::{Value, json}; struct AnthropicProtocol; impl RegistrationGuest for AnthropicProtocol { fn declare() -> Registrations { Registrations { credential_sources: vec![CredentialSource { id: "connection-api-key".to_string(), }], providers: vec![ProviderContribution { id: "anthropic".to_string(), protocol: ProtocolBinding::AnthropicMessages, credential_source_id: "connection-api-key".to_string(), }], models: Vec::new(), } } } impl PluginGuest for AnthropicProtocol { fn declare_tools() -> Vec { Vec::new() } fn invoke(_name: String, _input_json: String) -> Result { Err("protocol declares no tools".into()) } } impl ProviderGuest for AnthropicProtocol { fn declare_settings() -> ProviderSettings { ProviderSettings { include_usage: true, subscription: false, provenance: SettingsProvenance::BuiltIn, } } fn validate_settings(settings: ProviderSettings) -> Result { settings .include_usage .then_some(settings) .ok_or_else(|| "protocol setting include_usage must be true".into()) } fn build_request( model: String, request: ProviderRequest, settings: ProviderSettings, catalog: CatalogSnapshot, ) -> Result { Self::validate_settings(settings)?; if !catalog.models.iter().any(|entry| entry.id == model) { return Err("provider catalog snapshot does not admit model".into()); } let mut system = String::new(); let mut messages = Vec::new(); for message in request.messages { match message.role { MessageRole::System => { if !system.is_empty() { system.push('\n'); } system.push_str(&text(&message.blocks)); } MessageRole::User => messages.push( json!({"role":"user","content":[{"type":"text","text":text(&message.blocks)}]}), ), MessageRole::Assistant => messages .push(json!({"role":"assistant","content":assistant_blocks(&message.blocks)?})), MessageRole::Tool => { messages.push(json!({"role":"user","content":tool_results(&message.blocks)})) } } } let mut body = json!({"model":model,"max_tokens":request.output_tokens_max.unwrap_or(4096),"messages":messages,"stream":true}); if settings.subscription { let mut blocks = vec![ json!({"type":"text","text":"You are Claude Code, Anthropic's official CLI for Claude."}), ]; if !system.is_empty() { blocks.push(json!({"type":"text","text":system})); } body["system"] = Value::Array(blocks); } else if !system.is_empty() { body["system"] = json!(system); } if !request.tools.is_empty() { body["tools"] = Value::Array(request.tools.into_iter().map(|tool| serde_json::from_str::(&tool.input_schema_json).map(|schema| json!({"name":tool.name,"description":tool.description,"input_schema":schema})).map_err(|error| format!("tool schema is not JSON: {error}"))).collect::>()?); } Ok(RequestTemplate { url: "https://protocol.invalid/messages".into(), authorization: "{{secret:anthropic-connection}}".into(), body: body.to_string(), }) } fn decode_response( state: Vec, chunk: Vec, finished: bool, ) -> Result { let mut state: Value = if state.is_empty() { json!({"pending":[],"tools":{},"usage":{"input":0,"output":0,"hit":0,"write":0},"reason":null,"stopped":false}) } else { serde_json::from_slice(&state).map_err(|e| e.to_string())? }; let mut pending = state["pending"] .as_array() .ok_or("invalid codec pending bytes")? .iter() .map(|byte| { byte.as_u64() .and_then(|n| u8::try_from(n).ok()) .ok_or("invalid codec pending byte") }) .collect::, _>>()?; pending.extend(chunk); let mut events = Vec::new(); while let Some((data, rest)) = sse(&pending) { pending = rest; process( &mut state, std::str::from_utf8(&data).map_err(|e| e.to_string())?, &mut events, )?; } if finished { if !pending.is_empty() { process( &mut state, std::str::from_utf8(&pending).map_err(|e| e.to_string())?, &mut events, )?; } if !state["stopped"].as_bool().unwrap_or(false) { return Err("provider stream ended before message_stop".into()); } pending.clear(); } state["pending"] = json!(pending); Ok(DecodeStep { state: serde_json::to_vec(&state).map_err(|e| e.to_string())?, events, }) } } fn text(blocks: &[MessageBlock]) -> String { blocks .iter() .filter_map(|block| { if let MessageBlock::Text(text) = block { Some(text.as_str()) } else { None } }) .collect::>() .join("\n") } fn assistant_blocks(blocks: &[MessageBlock]) -> Result, String> { blocks.iter().filter_map(|block| match block { MessageBlock::Text(text) => Some(Ok(json!({"type":"text","text":text}))), MessageBlock::ToolUse(call) => Some(serde_json::from_str::(&call.input_json).map(|input| json!({"type":"tool_use","id":call.call_id,"name":call.name,"input":input})).map_err(|e| format!("tool arguments are not JSON: {e}"))), _ => None }).collect() } fn tool_results(blocks: &[MessageBlock]) -> Vec { blocks.iter().filter_map(|block| if let MessageBlock::ToolResult(result) = block { Some(json!({"type":"tool_result","tool_use_id":result.call_id,"content":result.output})) } else { None }).collect() } fn sse(bytes: &[u8]) -> Option<(Vec, Vec)> { let mut data = Vec::new(); let mut consumed = 0; for raw in bytes.split_inclusive(|byte| *byte == b'\n') { let length = raw.len(); let line = raw.strip_suffix(b"\n").unwrap_or(raw); let line = line.strip_suffix(b"\r").unwrap_or(line); if line.is_empty() { if !data.is_empty() { return Some((data, bytes[consumed + length..].to_vec())); } } else if let Some(value) = line.strip_prefix(b"data:") { data.extend_from_slice(value.strip_prefix(b" ").unwrap_or(value)); } consumed += length; } None } fn process(state: &mut Value, data: &str, events: &mut Vec) -> Result<(), String> { let value: Value = serde_json::from_str(data.trim()).map_err(|e| format!("event payload is not JSON: {e}"))?; match value["type"].as_str() { Some("message_start") => { state["usage"]["input"] = value .pointer("/message/usage/input_tokens") .cloned() .unwrap_or_else(|| json!(0)); } Some("content_block_start") => { if value.pointer("/content_block/type").and_then(Value::as_str) == Some("tool_use") { let index = value["index"] .as_u64() .ok_or("tool block without index")? .to_string(); state["tools"][index] = json!({"call_id":value.pointer("/content_block/id").and_then(Value::as_str).ok_or("tool block without id")?,"name":value.pointer("/content_block/name").and_then(Value::as_str).ok_or("tool block without name")?,"input":""}); } } Some("content_block_delta") => match value.pointer("/delta/type").and_then(Value::as_str) { Some("text_delta") => { if let Some(text) = value .pointer("/delta/text") .and_then(Value::as_str) .filter(|x| !x.is_empty()) { events.push(StreamEvent::Text(text.into())); } } Some("thinking_delta") => { if let Some(text) = value .pointer("/delta/thinking") .and_then(Value::as_str) .filter(|x| !x.is_empty()) { events.push(StreamEvent::Thinking(text.into())); } } Some("input_json_delta") => { let index = value["index"] .as_u64() .ok_or("tool delta without index")? .to_string(); state["tools"][&index]["input"] = json!(format!( "{}{}", state["tools"][&index]["input"].as_str().unwrap_or_default(), value .pointer("/delta/partial_json") .and_then(Value::as_str) .unwrap_or_default() )); } Some(kind) => return Err(format!("unknown delta type {kind}")), None => return Err("content block delta without type".into()), }, Some("message_delta") => { state["reason"] = value .pointer("/delta/stop_reason") .cloned() .unwrap_or(Value::Null); for (field, path) in [ ("output", "/usage/output_tokens"), ("hit", "/usage/cache_read_input_tokens"), ("write", "/usage/cache_creation_input_tokens"), ] { if let Some(number) = value.pointer(path).and_then(Value::as_u64) { state["usage"][field] = json!(number); } } } Some("message_stop") => { let reason = match state["reason"] .as_str() .ok_or("message_stop without stop reason")? { "end_turn" => StopReason::EndTurn, "max_tokens" => StopReason::Limit, "tool_use" => StopReason::ToolUse, "stop_sequence" => StopReason::StopSequence, "refusal" => StopReason::Refusal, "pause_turn" => { return Err("pause_turn requires server-side tool result handling".into()); } other => return Err(format!("unmapped stop reason {other}")), }; let tools = state["tools"].as_object().ok_or("invalid tool state")?; if !tools.is_empty() { return Err("message_stop with unfinished tool blocks".into()); } events.push(StreamEvent::Stop(( reason, Some(Usage { input_tokens: state["usage"]["input"].as_u64().unwrap_or(0), output_tokens: state["usage"]["output"].as_u64().unwrap_or(0), input_cache_hit_tokens: state["usage"]["hit"].as_u64().unwrap_or(0), input_cache_write_tokens: state["usage"]["write"].as_u64().unwrap_or(0), }), ))); state["stopped"] = json!(true); } Some("content_block_stop") => { let index = value["index"] .as_u64() .ok_or("tool stop without index")? .to_string(); if let Some(tool) = state["tools"] .as_object_mut() .ok_or("invalid tool state")? .remove(&index) { let input = tool["input"].as_str().unwrap_or_default(); let input = if input.trim().is_empty() { "{}".to_string() } else { serde_json::from_str::(input) .map_err(|e| format!("partial_json arguments do not assemble: {e}"))? .to_string() }; events.push(StreamEvent::ToolUse(ToolUse { name: tool["name"] .as_str() .ok_or("tool block without name")? .into(), input_json: input, call_id: tool["call_id"] .as_str() .ok_or("tool block without id")? .into(), })); } } Some("ping") => {} Some("error") => { return Err(value .pointer("/error/message") .and_then(Value::as_str) .unwrap_or("provider error") .into()); } other => return Err(format!("unknown event type {other:?}")), }; Ok(()) } export!(AnthropicProtocol);