use serde::Serialize;
use serde_json::{json, Map, Value};
use crate::agent::context::AgentEvent;
use crate::ai::types::{
AssistantMessage, ContentBlock, Message, StopReason, ToolResultContent, ToolResultMessage,
Usage,
};
#[derive(Debug, Clone)]
pub struct MapCtx {
pub session_id: String,
pub model: String,
pub cwd: String,
pub permission_mode: String,
usage: Usage,
num_turns: usize,
final_text: String,
last_stop_reason: Option<String>,
error: Option<String>,
pub duration_ms: u64,
}
impl MapCtx {
pub fn new(
session_id: impl Into<String>,
model: impl Into<String>,
cwd: impl Into<String>,
permission_mode: impl Into<String>,
) -> Self {
Self {
session_id: session_id.into(),
model: model.into(),
cwd: cwd.into(),
permission_mode: permission_mode.into(),
usage: Usage::default(),
num_turns: 0,
final_text: String::new(),
last_stop_reason: None,
error: None,
duration_ms: 0,
}
}
pub fn set_duration_ms(&mut self, ms: u64) {
self.duration_ms = ms;
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "type")]
pub enum ClaudeLine {
#[serde(rename = "system")]
System {
subtype: String,
#[serde(skip_serializing_if = "Option::is_none")]
cwd: Option<String>,
session_id: String,
model: String,
#[serde(rename = "permissionMode", skip_serializing_if = "Option::is_none")]
permission_mode: Option<String>,
tools: Vec<String>,
#[serde(rename = "mcpServers", skip_serializing_if = "Option::is_none")]
mcp_servers: Option<Value>,
version: String,
},
#[serde(rename = "assistant")]
Assistant {
message: Value,
session_id: String,
},
#[serde(rename = "user")]
User {
message: Value,
session_id: String,
},
#[serde(rename = "result")]
Result {
subtype: String,
is_error: bool,
result: String,
session_id: String,
#[serde(rename = "total_cost_usd")]
total_cost_usd: f64,
duration_ms: u64,
num_turns: u64,
model: String,
#[serde(skip_serializing_if = "Option::is_none")]
stop_reason: Option<String>,
usage: Value,
#[serde(rename = "modelUsage")]
model_usage: Value,
},
}
impl ClaudeLine {
fn system(ctx: &MapCtx, tools: Vec<String>) -> Self {
ClaudeLine::System {
subtype: "init".to_string(),
cwd: Some(ctx.cwd.clone()),
session_id: ctx.session_id.clone(),
model: ctx.model.clone(),
permission_mode: Some(ctx.permission_mode.clone()),
tools,
mcp_servers: Some(json!({})),
version: env!("CARGO_PKG_VERSION").to_string(),
}
}
fn assistant(a: &AssistantMessage, ctx: &MapCtx) -> Self {
let content: Vec<Value> = a.content.iter().map(map_content_block).collect();
let message = json!({
"id": a.response_id.clone().unwrap_or_else(|| "msg_0".to_string()),
"type": "message",
"role": "assistant",
"model": if a.model.is_empty() { ctx.model.clone() } else { a.model.clone() },
"content": content,
"stop_reason": map_stop_reason(a.stop_reason).unwrap_or("end_turn"),
"stop_sequence": Value::Null,
"usage": usage_tokens(&a.usage),
});
ClaudeLine::Assistant {
message,
session_id: ctx.session_id.clone(),
}
}
fn user_tool_result(t: &ToolResultMessage, ctx: &MapCtx) -> Self {
let text: String = t
.content
.iter()
.filter_map(|c| match c {
ToolResultContent::Text { text } => Some(text.as_str()),
_ => None,
})
.collect::<Vec<_>>()
.join("\n");
let block = json!({
"type": "tool_result",
"tool_use_id": t.tool_call_id,
"content": text,
"is_error": t.is_error,
});
ClaudeLine::User {
message: json!({ "role": "user", "content": [block] }),
session_id: ctx.session_id.clone(),
}
}
fn result(ctx: &MapCtx) -> Self {
let is_error = ctx.error.is_some();
let result_text = ctx
.error
.clone()
.unwrap_or_else(|| ctx.final_text.clone());
let model_usage = per_model_usage(&ctx.model, &ctx.usage);
ClaudeLine::Result {
subtype: if is_error {
"error".to_string()
} else {
"success".to_string()
},
is_error,
result: result_text,
session_id: ctx.session_id.clone(),
total_cost_usd: ctx.usage.cost.total,
duration_ms: ctx.duration_ms,
num_turns: ctx.num_turns as u64,
model: ctx.model.clone(),
stop_reason: ctx.last_stop_reason.clone(),
usage: usage_tokens(&ctx.usage),
model_usage,
}
}
}
pub fn map_events(ev: &AgentEvent, ctx: &mut MapCtx) -> Vec<ClaudeLine> {
let mut out = Vec::new();
match ev {
AgentEvent::Usage(u) => ctx.usage.add(u),
AgentEvent::MessageEnd(msg) => match msg {
Message::Assistant(a) => {
ctx.num_turns += 1;
if let Some(err) = &a.error_message {
ctx.error = Some(err.clone());
}
ctx.last_stop_reason = map_stop_reason(a.stop_reason).map(str::to_string);
let text = a.text_content();
if !text.is_empty() {
ctx.final_text = text;
}
out.push(ClaudeLine::assistant(a, ctx));
}
Message::ToolResult(t) => out.push(ClaudeLine::user_tool_result(t, ctx)),
Message::User(_) => {}
},
AgentEvent::Error(msg) => ctx.error = Some(msg.clone()),
AgentEvent::AgentEnd { messages } => {
if ctx.final_text.is_empty() {
if let Some(text) = messages.iter().rev().find_map(|m| match m {
Message::Assistant(a) => {
let t = a.text_content();
if t.is_empty() {
None
} else {
Some(t)
}
}
_ => None,
}) {
ctx.final_text = text;
}
}
out.push(ClaudeLine::result(ctx));
}
_ => {}
}
out
}
pub fn system_init(ctx: &MapCtx, tools: Vec<String>) -> ClaudeLine {
ClaudeLine::system(ctx, tools)
}
pub fn to_ndjson(line: &ClaudeLine) -> String {
serde_json::to_string(line).unwrap_or_default()
}
fn map_content_block(b: &ContentBlock) -> Value {
match b {
ContentBlock::Text { text } => json!({ "type": "text", "text": text }),
ContentBlock::Thinking { thinking, .. } => {
json!({ "type": "thinking", "thinking": thinking })
}
ContentBlock::ToolCall {
id,
name,
arguments,
} => json!({
"type": "tool_use",
"id": id,
"name": name,
"input": arguments,
}),
}
}
fn map_stop_reason(r: StopReason) -> Option<&'static str> {
Some(match r {
StopReason::Stop => "end_turn",
StopReason::Length => "max_tokens",
StopReason::ToolUse => "tool_use",
StopReason::Error | StopReason::Aborted => "end_turn",
})
}
fn usage_tokens(u: &Usage) -> Value {
json!({
"input_tokens": u.input,
"output_tokens": u.output,
"cache_creation_input_tokens": u.cache_write,
"cache_read_input_tokens": u.cache_read,
})
}
fn per_model_usage(model: &str, u: &Usage) -> Value {
let mut m = Map::new();
m.insert(
model.to_string(),
json!({
"inputTokens": u.input,
"outputTokens": u.output,
"cacheReadInputTokens": u.cache_read,
"cacheCreationInputTokens": u.cache_write,
}),
);
Value::Object(m)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ai::types::{AssistantMessage, ContentBlock, Message, ToolResultContent,
ToolResultMessage, Usage};
fn ctx() -> MapCtx {
MapCtx::new("sess-1", "claude-sonnet-4-6", "/tmp/proj", "bypassPermissions")
}
fn assistant_text(text: &str, usage: Usage) -> AssistantMessage {
let mut a = AssistantMessage::empty();
a.content.push(ContentBlock::Text {
text: text.to_string(),
});
a.usage = usage;
a
}
#[test]
fn system_init_has_init_subtype_and_model() {
let line = system_init(&ctx(), vec!["read".into(), "bash".into()]);
let v: Value = serde_json::from_str(&to_ndjson(&line)).unwrap();
assert_eq!(v["type"], "system");
assert_eq!(v["subtype"], "init");
assert_eq!(v["model"], "claude-sonnet-4-6");
assert_eq!(v["session_id"], "sess-1");
assert_eq!(v["permissionMode"], "bypassPermissions");
assert_eq!(v["cwd"], "/tmp/proj");
assert_eq!(v["tools"][0], "read");
}
#[test]
fn assistant_message_end_emits_assistant_line_with_text_block() {
let mut c = ctx();
let a = assistant_text("Hello", Usage::default());
let lines = map_events(
&AgentEvent::MessageEnd(Message::Assistant(a)),
&mut c,
);
assert_eq!(lines.len(), 1);
let v: Value = serde_json::from_str(&to_ndjson(&lines[0])).unwrap();
assert_eq!(v["type"], "assistant");
assert_eq!(v["session_id"], "sess-1");
assert_eq!(v["message"]["role"], "assistant");
assert_eq!(v["message"]["content"][0]["type"], "text");
assert_eq!(v["message"]["content"][0]["text"], "Hello");
}
#[test]
fn tool_call_block_is_tool_use_with_input_not_arguments() {
let mut c = ctx();
let mut a = AssistantMessage::empty();
a.content.push(ContentBlock::ToolCall {
id: "tu_1".into(),
name: "read".into(),
arguments: json!({ "path": "/a" }),
});
let lines = map_events(&AgentEvent::MessageEnd(Message::Assistant(a)), &mut c);
let block = serde_json::from_str::<Value>(&to_ndjson(&lines[0])).unwrap()["message"]
["content"][0]
.clone();
assert_eq!(block["type"], "tool_use");
assert_eq!(block["id"], "tu_1");
assert_eq!(block["name"], "read");
assert_eq!(block["input"]["path"], "/a");
assert!(block.get("arguments").is_none());
}
#[test]
fn tool_result_message_end_emits_user_line_with_tool_result_block() {
let mut c = ctx();
let t = ToolResultMessage {
tool_call_id: "tu_1".into(),
tool_name: "read".into(),
content: vec![ToolResultContent::text("file body")],
is_error: false,
timestamp: 0,
};
let lines = map_events(&AgentEvent::MessageEnd(Message::ToolResult(t)), &mut c);
assert_eq!(lines.len(), 1);
let v: Value = serde_json::from_str(&to_ndjson(&lines[0])).unwrap();
assert_eq!(v["type"], "user");
assert_eq!(v["message"]["role"], "user");
assert_eq!(v["message"]["content"][0]["type"], "tool_result");
assert_eq!(v["message"]["content"][0]["tool_use_id"], "tu_1");
assert_eq!(v["message"]["content"][0]["content"], "file body");
assert_eq!(v["message"]["content"][0]["is_error"], false);
}
#[test]
fn user_prompt_is_not_echoed_as_a_user_line() {
let mut c = ctx();
let prompt = Message::User(crate::ai::types::UserMessage::text("ignored prompt"));
let lines = map_events(&AgentEvent::MessageEnd(prompt), &mut c);
assert!(lines.is_empty(), "injected user prompt must not be echoed");
}
#[test]
fn usage_event_accumulates_into_context_and_emits_no_line() {
let mut c = ctx();
let a = assistant_text("Hi", Usage::default());
map_events(&AgentEvent::MessageEnd(Message::Assistant(a)), &mut c);
let lines = map_events(
&AgentEvent::Usage(Usage {
input: 100,
output: 40,
cache_read: 5,
cache_write: 2,
..Usage::default()
}),
&mut c,
);
assert!(lines.is_empty());
}
#[test]
fn agent_end_emits_exactly_one_result_line_with_totals() {
let mut c = ctx();
let a = assistant_text("final answer", Usage::default());
map_events(&AgentEvent::MessageEnd(Message::Assistant(a)), &mut c);
map_events(
&AgentEvent::Usage(Usage {
input: 100,
output: 40,
cache_read: 5,
cache_write: 2,
cost: crate::ai::types::Cost {
total: 0.0123,
..Default::default()
},
..Usage::default()
}),
&mut c,
);
c.set_duration_ms(1500);
let lines = map_events(
&AgentEvent::AgentEnd {
messages: Vec::new(),
},
&mut c,
);
assert_eq!(lines.len(), 1, "AgentEnd ⇒ exactly one result line");
let v: Value = serde_json::from_str(&to_ndjson(&lines[0])).unwrap();
assert_eq!(v["type"], "result");
assert_eq!(v["subtype"], "success");
assert_eq!(v["is_error"], false);
assert_eq!(v["result"], "final answer");
assert_eq!(v["num_turns"], 1);
assert_eq!(v["duration_ms"], 1500);
assert_eq!(v["total_cost_usd"], 0.0123);
assert_eq!(v["usage"]["input_tokens"], 100);
assert_eq!(v["usage"]["output_tokens"], 40);
assert_eq!(v["usage"]["cache_creation_input_tokens"], 2);
assert_eq!(v["usage"]["cache_read_input_tokens"], 5);
assert_eq!(v["modelUsage"]["claude-sonnet-4-6"]["inputTokens"], 100);
assert_eq!(v["modelUsage"]["claude-sonnet-4-6"]["outputTokens"], 40);
}
#[test]
fn full_tool_use_turn_sequences_assistant_user_result() {
let mut c = ctx();
let mut a1 = AssistantMessage::empty();
a1.stop_reason = StopReason::ToolUse;
a1.content.push(ContentBlock::ToolCall {
id: "tu_1".into(),
name: "read".into(),
arguments: json!({ "path": "/a" }),
});
let l1 = map_events(&AgentEvent::MessageEnd(Message::Assistant(a1)), &mut c);
let t = ToolResultMessage {
tool_call_id: "tu_1".into(),
tool_name: "read".into(),
content: vec![ToolResultContent::text("ok")],
is_error: false,
timestamp: 0,
};
let l2 = map_events(&AgentEvent::MessageEnd(Message::ToolResult(t)), &mut c);
let mut a2 = AssistantMessage::empty();
a2.content.push(ContentBlock::Text {
text: "done".into(),
});
let l3 = map_events(&AgentEvent::MessageEnd(Message::Assistant(a2)), &mut c);
let l4 = map_events(
&AgentEvent::AgentEnd {
messages: Vec::new(),
},
&mut c,
);
let line_of = |ls: Vec<ClaudeLine>| {
serde_json::from_str::<Value>(&to_ndjson(&ls[0])).unwrap()["type"]
.clone()
};
assert_eq!(line_of(l1), "assistant");
assert_eq!(line_of(l2), "user");
assert_eq!(line_of(l3), "assistant");
assert_eq!(line_of(l4), "result");
assert_eq!(c.num_turns, 2, "two assistant turns in a tool-use run");
}
#[test]
fn fatal_error_surfaces_in_result_line_as_error() {
let mut c = ctx();
let a = assistant_text("partial", Usage::default());
map_events(&AgentEvent::MessageEnd(Message::Assistant(a)), &mut c);
map_events(&AgentEvent::Error("boom".into()), &mut c);
let lines = map_events(
&AgentEvent::AgentEnd {
messages: Vec::new(),
},
&mut c,
);
let v: Value = serde_json::from_str(&to_ndjson(&lines[0])).unwrap();
assert_eq!(v["type"], "result");
assert_eq!(v["is_error"], true);
assert_eq!(v["subtype"], "error");
assert_eq!(v["result"], "boom", "error message becomes the result text");
}
#[test]
fn to_ndjson_round_trips_through_serde() {
let line = system_init(&ctx(), Vec::new());
let s = to_ndjson(&line);
assert!(!s.contains('\n'), "a line has no embedded newline");
let v: Value = serde_json::from_str(&s).unwrap();
assert_eq!(v["type"], "system");
}
}