use std::time::Duration;
use async_trait::async_trait;
use serde_json::Value;
use super::{cli_version, run_cli_capture, Consolidator, ConsolidatorIdentity, DEFAULT_TIMEOUT};
use crate::error::{MemdError, Result};
pub const DEFAULT_MODEL: &str = "claude-haiku-4-5-20251001";
pub struct ClaudeHaikuConsolidator {
model: String,
timeout: Duration,
}
impl Default for ClaudeHaikuConsolidator {
fn default() -> Self {
Self {
model: DEFAULT_MODEL.to_string(),
timeout: DEFAULT_TIMEOUT,
}
}
}
impl ClaudeHaikuConsolidator {
pub fn new(model: impl Into<String>, timeout: Duration) -> Self {
Self {
model: model.into(),
timeout,
}
}
}
#[async_trait]
impl Consolidator for ClaudeHaikuConsolidator {
async fn consolidate(&self, prompt: &str) -> Result<String> {
let args = [
"-p",
"--model",
self.model.as_str(),
"--output-format",
"json",
];
let stdout = run_cli_capture("claude", &args, prompt, self.timeout).await?;
extract_claude_result(&stdout)
}
fn name(&self) -> &'static str {
"claude-haiku"
}
async fn identity(&self) -> Result<ConsolidatorIdentity> {
Ok(ConsolidatorIdentity {
adapter: self.name().to_string(),
command: Some(format!(
"claude -p --model {} --output-format json",
self.model
)),
model: Some(self.model.clone()),
version: Some(cli_version("claude", self.timeout).await?),
})
}
}
pub(crate) fn extract_claude_result(stdout: &str) -> Result<String> {
let value: Value = serde_json::from_str(stdout.trim())
.map_err(|e| MemdError::ValidationError(format!("claude returned non-JSON output: {e}")))?;
if value.get("is_error").and_then(Value::as_bool) == Some(true) {
return Err(MemdError::ProtocolError(
"claude reported is_error=true".to_string(),
));
}
value
.get("result")
.and_then(Value::as_str)
.map(str::to_string)
.ok_or_else(|| {
MemdError::ValidationError(
"claude JSON output missing string `result` field".to_string(),
)
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn extracts_result_field() {
let stdout = r#"{"type":"result","result":"[{\"text\":\"x\"}]","is_error":false}"#;
assert_eq!(extract_claude_result(stdout).unwrap(), "[{\"text\":\"x\"}]");
}
#[test]
fn rejects_is_error() {
let stdout = r#"{"result":"oops","is_error":true}"#;
assert!(extract_claude_result(stdout).is_err());
}
#[test]
fn rejects_non_json() {
assert!(extract_claude_result("not json").is_err());
}
#[test]
fn rejects_missing_result() {
assert!(extract_claude_result(r#"{"type":"result"}"#).is_err());
}
}