diff --git a/atomic-agent/src/hooks/grok.rs b/atomic-agent/src/hooks/grok.rs index 896d736e..ae1836fc 100644 --- a/atomic-agent/src/hooks/grok.rs +++ b/atomic-agent/src/hooks/grok.rs @@ -19,10 +19,13 @@ //! # JSON shape //! //! Grok's stdin envelope uses camelCase throughout (`sessionId`, `toolName`, -//! `toolResult`, …). Claude Code compatibility aliases are accepted via -//! serde `alias` so shared scripts still parse. Every event also carries -//! `cwd` / `workspaceRoot` which we surface as repo-root hints when the -//! process cwd is not the workspace. +//! `toolResult`, …) and, for Claude Code compatibility, repeats most +//! top-level keys in snake_case in the same payload (`session_id`, +//! `tool_name`, `tool_response`, …). `hookEventName` and `hook_event_name` +//! even carry different values (`stop` vs `Stop`). Either spelling is +//! accepted, alone or together; see `FIELD_SPELLINGS`. Every event also +//! carries `cwd` / `workspaceRoot` which we surface as repo-root hints when +//! the process cwd is not the workspace. //! //! `Stop` fires both on genuine turn completion (`reason: "end_turn"`) and //! once more at session end (`channel_closed` / `shutdown`). Both map to @@ -48,17 +51,43 @@ const ATOMIC_HOOK_PREFIX: &str = "atomic agent hooks grok"; // JSON input types (camelCase primary, snake_case aliases) +/// Spellings Grok may send for one [`CommonInput`] field, preferred first. +/// +/// One payload can carry several spellings of the same field, which serde +/// `alias` rejects as a duplicate field, so [`canonicalize_fields`] folds +/// them into the field name before deserializing. +const FIELD_SPELLINGS: &[(&str, &[&str])] = &[ + ("session_id", &["sessionId", "session_id"]), + ("transcript_path", &["transcriptPath", "transcript_path"]), + ("workspace_root", &["workspaceRoot", "workspace_root"]), + ("tool_name", &["toolName", "tool_name"]), + ("tool_use_id", &["toolUseId", "tool_use_id"]), + ("tool_input", &["toolInput", "tool_input"]), + ( + "tool_result", + &["toolResult", "tool_result", "tool_response"], + ), + ("stop_hook_active", &["stopHookActive", "stop_hook_active"]), + ( + "last_assistant_message", + &["lastAssistantMessage", "last_assistant_message"], + ), + ("permission_mode", &["permissionMode", "permission_mode"]), + ("hook_event_name", &["hookEventName", "hook_event_name"]), +]; + +/// Fields arrive under their own name: [`canonicalize_fields`] has already +/// folded every spelling in [`FIELD_SPELLINGS`]. #[derive(Debug, Deserialize)] #[allow(dead_code)] struct CommonInput { - // Grok primary: camelCase. Aliases accept Claude-style snake_case scripts. - #[serde(default, alias = "sessionId")] + #[serde(default)] session_id: Option, - #[serde(default, alias = "transcriptPath")] + #[serde(default)] transcript_path: Option, #[serde(default)] cwd: Option, - #[serde(default, alias = "workspaceRoot")] + #[serde(default)] workspace_root: Option, #[serde(default)] model: Option, @@ -68,26 +97,26 @@ struct CommonInput { source: Option, #[serde(default)] prompt: Option, - #[serde(default, alias = "toolName")] + #[serde(default)] tool_name: Option, - #[serde(default, alias = "toolUseId")] + #[serde(default)] tool_use_id: Option, - #[serde(default, alias = "toolInput")] + #[serde(default)] tool_input: Option, - #[serde(default, alias = "toolResult", alias = "tool_response")] + #[serde(default)] tool_result: Option, /// Stop reason: `"end_turn"`, `"channel_closed"`, `"shutdown"`, … #[serde(default)] reason: Option, - #[serde(default, alias = "stopHookActive")] + #[serde(default)] stop_hook_active: Option, - #[serde(default, alias = "lastAssistantMessage")] + #[serde(default)] last_assistant_message: Option, #[serde(default)] timestamp: Option, - #[serde(default, alias = "permissionMode")] + #[serde(default)] permission_mode: Option, - #[serde(default, alias = "hookEventName")] + #[serde(default)] hook_event_name: Option, } @@ -171,7 +200,7 @@ impl AgentHook for GrokHook { fn parse_event(&self, hook_type: HookType, input: &[u8]) -> AgentResult { let raw_json = self.parse_json(hook_type, input)?; let timestamp = TimestampFormat::Rfc3339.parse(self.name(), hook_type, &raw_json)?; - let parsed = self.parse_common(hook_type, raw_json.clone())?; + let parsed = self.parse_common(hook_type, canonicalize_fields(&raw_json))?; let mut raw_json = with_xai_provider(raw_json); if hook_type == HookType::TurnEnd { @@ -296,6 +325,34 @@ impl AgentHook for GrokHook { // Normalization helpers +/// Rewrite the envelope so each [`CommonInput`] field appears once, under +/// its own name. +/// +/// The first spelling in [`FIELD_SPELLINGS`] with a non-null value wins. +/// Every other key passes through unchanged. +fn canonicalize_fields(raw: &Value) -> Value { + let Some(obj) = raw.as_object() else { + return raw.clone(); + }; + let is_spelling = |key: &str| { + FIELD_SPELLINGS + .iter() + .any(|(_, spellings)| spellings.contains(&key)) + }; + let untouched = obj + .iter() + .filter(|(key, _)| !is_spelling(key)) + .map(|(key, value)| (key.clone(), value.clone())); + let folded = FIELD_SPELLINGS.iter().filter_map(|(field, spellings)| { + spellings + .iter() + .filter_map(|spelling| obj.get(*spelling)) + .find(|value| !value.is_null()) + .map(|value| (field.to_string(), value.clone())) + }); + Value::Object(untouched.chain(folded).collect()) +} + /// Strip Grok harness wrappers from a user prompt. /// /// Grok's agent runtime delivers the human message inside an XML-ish envelope: @@ -634,6 +691,54 @@ mod tests { assert_eq!(raw.get("provider").and_then(Value::as_str), Some("xai")); } + // Real payloads carrying both spellings of every field are covered in + // `tests/grok_real_payloads.rs`. + #[test] + fn test_parse_prefers_camel_case_when_spellings_disagree() { + let hook = make_hook(); + let input = br#"{"sessionId": "camel", "session_id": "snake"}"#; + let event = hook.parse_event(HookType::SessionStart, input).unwrap(); + assert_eq!(event.session_id, "camel"); + } + + #[test] + fn test_parse_skips_a_null_spelling() { + let hook = make_hook(); + let input = br#"{"sessionId": null, "session_id": "snake"}"#; + let event = hook.parse_event(HookType::SessionStart, input).unwrap(); + assert_eq!(event.session_id, "snake"); + } + + #[test] + fn test_parse_every_spelling_null() { + let hook = make_hook(); + let input = br#"{"sessionId": null, "session_id": null}"#; + let event = hook.parse_event(HookType::SessionStart, input).unwrap(); + assert!(event.session_id.starts_with("grok-")); + } + + #[test] + fn test_parse_tool_result_under_every_spelling() { + let hook = make_hook(); + let input = br#"{ + "sessionId": "s1", + "toolResult": "camel", + "tool_result": "sdk", + "tool_response": "claude" + }"#; + let event = hook.parse_event(HookType::PostToolUse, input).unwrap(); + let raw = event.raw_json.unwrap(); + assert_eq!( + raw.get("tool_output").and_then(Value::as_str), + Some("camel") + ); + // The envelope reaches downstream as Grok sent it. + assert_eq!( + raw.get("tool_response").and_then(Value::as_str), + Some("claude") + ); + } + #[test] fn test_parse_empty_input() { let hook = make_hook(); diff --git a/atomic-agent/tests/fixtures/grok-1.0.77/post_tool_use.json b/atomic-agent/tests/fixtures/grok-1.0.77/post_tool_use.json new file mode 100644 index 00000000..f7068d6f --- /dev/null +++ b/atomic-agent/tests/fixtures/grok-1.0.77/post_tool_use.json @@ -0,0 +1,54 @@ +{ + "hookEventName": "post_tool_use", + "sessionId": "01a1d576-264a-7530-a25e-d209bd34a860", + "cwd": "/Users/you/project", + "workspaceRoot": "/Users/you/project", + "timestamp": "2026-11-13T15:10:58.231423+00:00", + "transcriptPath": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permissionMode": "default", + "toolName": "read_file", + "toolUseId": "call-e15f7982-e832-4e29-a8a6-0ea59a23b34b-0", + "toolInput": { + "target_file": "/Users/you/project/a.txt", + "limit": 5 + }, + "toolResult": { + "type": "ReadFile", + "FileContent": { + "content": "1→first line\n", + "content_concise": "1→first line\n", + "absolute_path": "/Users/you/project/a.txt", + "offset": null, + "limit": 5, + "raw_output": "first line\n", + "total_lines": 1 + } + }, + "toolInputTruncated": false, + "toolResultTruncated": false, + "durationMs": 5, + "isBackgrounded": false, + "hook_event_name": "PostToolUse", + "session_id": "01a1d576-264a-7530-a25e-d209bd34a860", + "transcript_path": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permission_mode": "default", + "tool_name": "read_file", + "tool_input": { + "target_file": "/Users/you/project/a.txt", + "limit": 5 + }, + "tool_response": { + "type": "ReadFile", + "FileContent": { + "content": "1→first line\n", + "content_concise": "1→first line\n", + "absolute_path": "/Users/you/project/a.txt", + "offset": null, + "limit": 5, + "raw_output": "first line\n", + "total_lines": 1 + } + }, + "tool_use_id": "call-e15f7982-e832-4e29-a8a6-0ea59a23b34b-0", + "duration_ms": 5 +} diff --git a/atomic-agent/tests/fixtures/grok-1.0.77/pre_tool_use.json b/atomic-agent/tests/fixtures/grok-1.0.77/pre_tool_use.json new file mode 100644 index 00000000..512e2a41 --- /dev/null +++ b/atomic-agent/tests/fixtures/grok-1.0.77/pre_tool_use.json @@ -0,0 +1,26 @@ +{ + "hookEventName": "pre_tool_use", + "sessionId": "01a1d576-264a-7530-a25e-d209bd34a860", + "cwd": "/Users/you/project", + "workspaceRoot": "/Users/you/project", + "timestamp": "2026-11-13T15:10:58.171140+00:00", + "transcriptPath": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permissionMode": "default", + "toolName": "read_file", + "toolUseId": "call-e15f7982-e832-4e29-a8a6-0ea59a23b34b-0", + "toolInput": { + "target_file": "/Users/you/project/a.txt", + "limit": 5 + }, + "toolInputTruncated": false, + "hook_event_name": "PreToolUse", + "session_id": "01a1d576-264a-7530-a25e-d209bd34a860", + "transcript_path": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permission_mode": "default", + "tool_name": "read_file", + "tool_input": { + "target_file": "/Users/you/project/a.txt", + "limit": 5 + }, + "tool_use_id": "call-e15f7982-e832-4e29-a8a6-0ea59a23b34b-0" +} diff --git a/atomic-agent/tests/fixtures/grok-1.0.77/session_end.json b/atomic-agent/tests/fixtures/grok-1.0.77/session_end.json new file mode 100644 index 00000000..ccb76389 --- /dev/null +++ b/atomic-agent/tests/fixtures/grok-1.0.77/session_end.json @@ -0,0 +1,14 @@ +{ + "hookEventName": "session_end", + "sessionId": "01a1d576-264a-7530-a25e-d209bd34a860", + "cwd": "/Users/you/project", + "workspaceRoot": "/Users/you/project", + "timestamp": "2026-11-13T15:11:00.474405+00:00", + "transcriptPath": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permissionMode": "default", + "reason": "shutdown", + "hook_event_name": "SessionEnd", + "session_id": "01a1d576-264a-7530-a25e-d209bd34a860", + "transcript_path": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permission_mode": "default" +} diff --git a/atomic-agent/tests/fixtures/grok-1.0.77/session_start.json b/atomic-agent/tests/fixtures/grok-1.0.77/session_start.json new file mode 100644 index 00000000..839b6e4c --- /dev/null +++ b/atomic-agent/tests/fixtures/grok-1.0.77/session_start.json @@ -0,0 +1,12 @@ +{ + "hookEventName": "session_start", + "sessionId": "01a1d576-264a-7530-a25e-d209bd34a860", + "cwd": "/Users/you/project", + "workspaceRoot": "/Users/you/project", + "timestamp": "2026-11-13T15:10:52.790226+00:00", + "permissionMode": "default", + "source": "new", + "hook_event_name": "SessionStart", + "session_id": "01a1d576-264a-7530-a25e-d209bd34a860", + "permission_mode": "default" +} diff --git a/atomic-agent/tests/fixtures/grok-1.0.77/stop_end_turn.json b/atomic-agent/tests/fixtures/grok-1.0.77/stop_end_turn.json new file mode 100644 index 00000000..aaa1aafc --- /dev/null +++ b/atomic-agent/tests/fixtures/grok-1.0.77/stop_end_turn.json @@ -0,0 +1,21 @@ +{ + "hookEventName": "stop", + "sessionId": "01a1d576-264a-7530-a25e-d209bd34a860", + "cwd": "/Users/you/project", + "workspaceRoot": "/Users/you/project", + "timestamp": "2026-11-13T15:11:00.132019+00:00", + "transcriptPath": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "promptId": "521d4615-47f7-4ad8-adde-307836fe26fc", + "permissionMode": "default", + "reason": "end_turn", + "stopHookActive": false, + "lastAssistantMessage": "The first line of `a.txt` is:\n\n```\nfirst line\n```", + "backgroundTasks": [], + "sessionCrons": [], + "hook_event_name": "Stop", + "session_id": "01a1d576-264a-7530-a25e-d209bd34a860", + "transcript_path": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permission_mode": "default", + "stop_hook_active": false, + "last_assistant_message": "The first line of `a.txt` is:\n\n```\nfirst line\n```" +} diff --git a/atomic-agent/tests/fixtures/grok-1.0.77/stop_shutdown.json b/atomic-agent/tests/fixtures/grok-1.0.77/stop_shutdown.json new file mode 100644 index 00000000..fd0110de --- /dev/null +++ b/atomic-agent/tests/fixtures/grok-1.0.77/stop_shutdown.json @@ -0,0 +1,16 @@ +{ + "hookEventName": "stop", + "sessionId": "01a1d576-264a-7530-a25e-d209bd34a860", + "cwd": "/Users/you/project", + "workspaceRoot": "/Users/you/project", + "timestamp": "2026-11-13T15:11:00.476518+00:00", + "transcriptPath": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permissionMode": "default", + "reason": "shutdown", + "stopHookActive": false, + "hook_event_name": "Stop", + "session_id": "01a1d576-264a-7530-a25e-d209bd34a860", + "transcript_path": "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl", + "permission_mode": "default", + "stop_hook_active": false +} diff --git a/atomic-agent/tests/fixtures/grok-1.0.77/user_prompt_submit.json b/atomic-agent/tests/fixtures/grok-1.0.77/user_prompt_submit.json new file mode 100644 index 00000000..64a27181 --- /dev/null +++ b/atomic-agent/tests/fixtures/grok-1.0.77/user_prompt_submit.json @@ -0,0 +1,13 @@ +{ + "hookEventName": "user_prompt_submit", + "sessionId": "01a1d576-264a-7530-a25e-d209bd34a860", + "cwd": "/Users/you/project", + "workspaceRoot": "/Users/you/project", + "timestamp": "2026-11-13T15:10:52.842761+00:00", + "promptId": "521d4615-47f7-4ad8-adde-307836fe26fc", + "permissionMode": "default", + "prompt": "Read the file a.txt and tell me its first line. Do not modify anything.", + "hook_event_name": "UserPromptSubmit", + "session_id": "01a1d576-264a-7530-a25e-d209bd34a860", + "permission_mode": "default" +} diff --git a/atomic-agent/tests/grok_real_payloads.rs b/atomic-agent/tests/grok_real_payloads.rs new file mode 100644 index 00000000..af94fc7d --- /dev/null +++ b/atomic-agent/tests/grok_real_payloads.rs @@ -0,0 +1,111 @@ +//! Hook payloads captured from a real Grok Build 1.0.77 session. +//! +//! Grok sends its own camelCase key and Claude's snake_case key side by +//! side for most top-level fields. The fixtures keep every key, key order +//! and value Grok sent; only machine-specific paths are rewritten. + +use std::path::Path; + +use atomic_agent::event::{HookType, TurnEvent}; +use atomic_agent::hooks::AgentRegistry; +use serde_json::Value; + +const SESSION_ID: &str = "01a1d576-264a-7530-a25e-d209bd34a860"; +const TRANSCRIPT_PATH: &str = "/Users/you/.grok/sessions/%2FUsers%2Fyou%2Fproject/01a1d576-264a-7530-a25e-d209bd34a860/updates.jsonl"; + +const SESSION_START: &str = include_str!("fixtures/grok-1.0.77/session_start.json"); +const USER_PROMPT_SUBMIT: &str = include_str!("fixtures/grok-1.0.77/user_prompt_submit.json"); +const PRE_TOOL_USE: &str = include_str!("fixtures/grok-1.0.77/pre_tool_use.json"); +const POST_TOOL_USE: &str = include_str!("fixtures/grok-1.0.77/post_tool_use.json"); +const STOP_END_TURN: &str = include_str!("fixtures/grok-1.0.77/stop_end_turn.json"); +const STOP_SHUTDOWN: &str = include_str!("fixtures/grok-1.0.77/stop_shutdown.json"); +const SESSION_END: &str = include_str!("fixtures/grok-1.0.77/session_end.json"); + +fn parse(hook_type: HookType, payload: &str) -> TurnEvent { + let registry = AgentRegistry::with_defaults(); + let grok = registry.require("grok").unwrap(); + grok.parse_event(hook_type, payload.as_bytes()) + .unwrap_or_else(|error| panic!("grok {hook_type}: {error}")) +} + +fn raw_str<'a>(event: &'a TurnEvent, key: &str) -> Option<&'a str> { + event.raw_json.as_ref()?.get(key).and_then(Value::as_str) +} + +#[test] +fn every_real_payload_parses() { + let payloads = [ + (HookType::SessionStart, SESSION_START), + (HookType::TurnStart, USER_PROMPT_SUBMIT), + (HookType::PreToolUse, PRE_TOOL_USE), + (HookType::PostToolUse, POST_TOOL_USE), + (HookType::TurnEnd, STOP_END_TURN), + (HookType::TurnEnd, STOP_SHUTDOWN), + (HookType::SessionEnd, SESSION_END), + ]; + for (hook_type, payload) in payloads { + let event = parse(hook_type, payload); + assert_eq!(event.session_id, SESSION_ID, "{hook_type}"); + assert_eq!(event.event_type, hook_type); + assert_eq!(raw_str(&event, "provider"), Some("xai"), "{hook_type}"); + } +} + +#[test] +fn real_payloads_keep_both_spellings_in_raw_json() { + let event = parse(HookType::SessionStart, SESSION_START); + assert_eq!(raw_str(&event, "hookEventName"), Some("session_start")); + assert_eq!(raw_str(&event, "hook_event_name"), Some("SessionStart")); + assert_eq!(raw_str(&event, "sessionId"), Some(SESSION_ID)); + assert_eq!(raw_str(&event, "session_id"), Some(SESSION_ID)); +} + +#[test] +fn real_user_prompt_submit_carries_the_prompt() { + let event = parse(HookType::TurnStart, USER_PROMPT_SUBMIT); + assert_eq!( + event.prompt.as_deref(), + Some("Read the file a.txt and tell me its first line. Do not modify anything.") + ); +} + +#[test] +fn real_pre_tool_use_carries_the_tool_call() { + let event = parse(HookType::PreToolUse, PRE_TOOL_USE); + assert_eq!(event.tool_name.as_deref(), Some("read_file")); + assert_eq!( + event.tool_use_id.as_deref(), + Some("call-e15f7982-e832-4e29-a8a6-0ea59a23b34b-0") + ); + assert_eq!( + event.transcript_path.as_deref(), + Some(Path::new(TRANSCRIPT_PATH)) + ); +} + +#[test] +fn real_post_tool_use_carries_the_tool_result() { + let event = parse(HookType::PostToolUse, POST_TOOL_USE); + assert_eq!(event.tool_name.as_deref(), Some("read_file")); + assert_eq!(raw_str(&event, "status"), Some("completed")); + assert_eq!( + raw_str(&event, "file_path"), + Some("/Users/you/project/a.txt") + ); + let raw = event.raw_json.as_ref().unwrap(); + assert_eq!(raw.get("toolResult"), raw.get("tool_response")); + assert!(raw_str(&event, "tool_output").is_some_and(|output| output.contains("first line"))); +} + +#[test] +fn real_stop_maps_the_reason_onto_finish_reason() { + let end_turn = parse(HookType::TurnEnd, STOP_END_TURN); + assert_eq!(raw_str(&end_turn, "finish_reason"), Some("stop")); + assert_eq!( + raw_str(&end_turn, "last_assistant_message"), + Some("The first line of `a.txt` is:\n\n```\nfirst line\n```") + ); + + let shutdown = parse(HookType::TurnEnd, STOP_SHUTDOWN); + assert_eq!(raw_str(&shutdown, "finish_reason"), Some("session-end")); +}