Function build_turn_provenance

atomic-agent/src/record/provenance.rs:26–156

Build a `Provenance` entry for an agent turn. Populates vendor, model, tool, suggestion type, session ID, and prompt hash. Token usage and cost can be added later when that data is available from the agent's transcript.

(options: &TurnRecordOptions<'_>)

/// Token usage and cost can be added later when that data is available from
/// the agent's transcript.
pub(crate) fn build_turn_provenance(options: &TurnRecordOptions<'_>) -> Provenance {
    let vendor = if options.session.agent_vendor.is_empty() {
        vendor_from_agent_name(&options.session.agent_name)
    } else {
        AIVendor::parse(&options.session.agent_vendor)
    };

    let model = if options.session.model.is_empty() {
        "unknown".to_string()
    } else {
        options.session.model.clone()
    };

    let tool = AITool::Cli(options.session.agent_name.clone());

    let prompt_content = match &options.prompt {
        Some(prompt) if !prompt.is_empty() => PromptContent::Hashed(Hash::of(prompt.as_bytes())),
        _ => PromptContent::None,
    };

    let timestamp = options.event.timestamp.timestamp();

    // Extract enriched metadata from the raw JSON payload sent by the plugin.
    // The plugin accumulates data across all events within a turn and sends
    // it in the `stop` payload. All fields are optional — old plugins that
    // don't send them will simply leave these as None/default.
    let raw = options.event.raw_json.as_ref();

    // Helper closures for extracting typed values from raw JSON
    let raw_str = |key: &str| -> Option<String> {
        raw.and_then(|r| r.get(key))
            .and_then(|v| v.as_str())
            .map(|s| s.to_string())
    };
    let raw_u64 =
        |key: &str| -> Option<u64> { raw.and_then(|r| r.get(key)).and_then(|v| v.as_u64()) };
    let raw_f64 =
        |key: &str| -> Option<f64> { raw.and_then(|r| r.get(key)).and_then(|v| v.as_f64()) };
    let raw_u32 = |key: &str| -> Option<u32> {
        raw.and_then(|r| r.get(key))
            .and_then(|v| v.as_u64())
            .map(|n| n as u32)
    };

    // Token usage — now includes reasoning tokens
    let input = raw_u64("input_tokens").unwrap_or(0);
    let output = raw_u64("output_tokens").unwrap_or(0);
    let reasoning = raw_u64("reasoning_tokens").unwrap_or(0);
    let cache_read = raw_u64("cache_read_tokens").unwrap_or(0);
    let cache_write = raw_u64("cache_write_tokens").unwrap_or(0);

    let tokens = if input > 0 || output > 0 || reasoning > 0 || cache_read > 0 || cache_write > 0 {
        TokenUsage::full(input, output, reasoning, cache_read, cache_write)
    } else {
        TokenUsage::default()
    };

    // Cost