Method parse_event

atomic-agent/src/hooks/sherpa.rs:188–275

(&self, hook_type: HookType, input: &[u8])

    }

    fn parse_event(&self, hook_type: HookType, input: &[u8]) -> AgentResult<TurnEvent> {
        if input.is_empty() {
            return Err(AgentError::HookInputEmpty {
                agent: self.name().to_string(),
                hook_type: hook_type.as_str().to_string(),
            });
        }

        let (parsed, raw) = Self::parse_input(self.name(), hook_type, input)?;

        if parsed.session_id.is_empty() {
            return Err(AgentError::HookParseFailed {
                agent: self.name().to_string(),
                hook_type: hook_type.as_str().to_string(),
                reason: "session_id is empty".to_string(),
            });
        }

        let mut event = TurnEvent::new(parsed.session_id.clone(), hook_type).with_raw_json(raw);

        // Stamp model and provider so the orchestrator can persist them on
        // the AgentSession — same pattern as OpenCode.
        if let Some(model) = &parsed.model {
            if !model.is_empty() {
                if let Some(ref mut raw_json) = event.raw_json {
                    if let Some(obj) = raw_json.as_object_mut() {
                        obj.insert(
                            "model".to_string(),
                            serde_json::Value::String(model.clone()),
                        );
                    }
                }
            }
        }
        if let Some(provider) = &parsed.provider {
            if !provider.is_empty() {
                if let Some(ref mut raw_json) = event.raw_json {
                    if let Some(obj) = raw_json.as_object_mut() {
                        obj.insert(
                            "provider".to_string(),
                            serde_json::Value::String(provider.clone()),
                        );
                    }
                }
            }
        }

        match hook_type {
            HookType::TurnStart => {
                // intent_title doubles as the turn prompt — used by the
                // orchestrator to set session.current_prompt so the atomic
                // record message is meaningful.
                if let Some(title) = &parsed.intent_title {
                    event = event.with_prompt(title.clone());
                }
            }

            HookType::TurnEnd => {