runifold-agent 0.5.5

Structured model-tool agent runtime for Runifold
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! Agent checkpoint state conversion, persistence, and usage validation.

use super::{
    AgentCheckpointState, AgentError, AgentOutcome, CheckpointCursor,
    DurableConversationCheckpoint, Message, ModelResponse, Usage,
};

pub(super) struct AgentProgress {
    pub(super) execution_id: String,
    pub(super) transcript: Vec<Message>,
    pub(super) turns: u32,
    pub(super) tool_calls: u32,
    pub(super) delegations: u32,
    pub(super) terminal_repairs: u32,
    pub(super) durable_conversation: Option<DurableConversationCheckpoint>,
}

impl From<AgentCheckpointState> for AgentProgress {
    fn from(state: AgentCheckpointState) -> Self {
        let terminal_repairs = terminal_repair_count(&state.transcript);
        Self {
            execution_id: state.execution_id,
            transcript: state.transcript,
            turns: state.turns,
            tool_calls: state.tool_calls,
            delegations: state.delegations,
            terminal_repairs,
            durable_conversation: state.durable_conversation,
        }
    }
}

impl AgentProgress {
    pub(super) fn clone_outcome(&self, response: ModelResponse, usage: Usage) -> AgentOutcome {
        AgentOutcome {
            response,
            transcript: self.transcript.clone(),
            turns: self.turns,
            tool_calls: self.tool_calls,
            delegations: self.delegations,
            usage,
        }
    }
}

fn terminal_repair_count(transcript: &[Message]) -> u32 {
    transcript
        .iter()
        .filter(|message| {
            message.metadata.get("runifold.terminal_repair") == Some(&serde_json::Value::Bool(true))
        })
        .count()
        .try_into()
        .unwrap_or(u32::MAX)
}

pub(super) fn save_checkpoint(
    checkpoint: &mut Option<&mut CheckpointCursor>,
    state: &AgentCheckpointState,
) -> Result<(), AgentError> {
    if let Some(checkpoint) = checkpoint.as_deref_mut() {
        checkpoint.save(state)?;
    }
    Ok(())
}

pub(super) fn validate_exact_usage(expected: Usage, actual: Usage) -> Result<(), AgentError> {
    if expected != actual {
        return Err(checkpoint_payload_error(
            "Run budget usage does not match the checkpoint snapshot",
        ));
    }
    Ok(())
}

pub(super) fn validate_usage_floor(floor: Usage, actual: Usage) -> Result<(), AgentError> {
    let covers = actual.tokens >= floor.tokens
        && actual.cost_microusd >= floor.cost_microusd
        && actual.duration_micros >= floor.duration_micros
        && actual.turns >= floor.turns
        && actual.tool_calls >= floor.tool_calls
        && actual.delegations >= floor.delegations;
    if !covers {
        return Err(checkpoint_payload_error(
            "Run budget usage is below the in-flight checkpoint snapshot",
        ));
    }
    Ok(())
}

fn checkpoint_payload_error(message: &str) -> AgentError {
    runifold_core::CheckpointError::new(runifold_core::CheckpointErrorKind::InvalidPayload, message)
        .into()
}