Struct ExecutionRecord 

pub struct ExecutionRecord {

    pub key: String,
    pub agent_name: String,
    pub input_tokens: i64,
    pub output_tokens: i64,
    pub total_tokens: i64,
    pub cost_sub_cents: i64,
    pub model: Option<String>,
    pub provider: Option<String>,
    pub success: bool,
    pub error_message: Option<String>,
    pub latency_ms: Option<i64>,
    pub started_at: String,
    pub completed_at: Option<String>,
    pub gitea_issue: Option<i64>,
}

Persistable record for individual execution history entries

Maps to the execution_history table in SQLite schema.

Fields

key: String

Unique identifier for this record (auto-generated from timestamp + agent)

agent_name: String

Agent name that executed

input_tokens: i64

Input tokens consumed

output_tokens: i64

Output tokens consumed

total_tokens: i64

Total tokens (input + output)

cost_sub_cents: i64

Cost in sub-cents

model: Option<String>

Model used

provider: Option<String>

Provider used

success: bool

Whether execution succeeded

error_message: Option<String>

Error message if failed

latency_ms: Option<i64>

Latency in milliseconds

started_at: String

When execution started (RFC3339)

completed_at: Option<String>

When execution completed (RFC3339)

gitea_issue: Option<i64>

Associated Gitea issue number

Implementations

impl ExecutionRecord

pub fn cost_usd(&self) -> f64

Calculate cost in dollars

pub fn duration_ms(&self) -> Option<i64>

Get duration since started

pub fn from_llm_usage(usage: &LlmUsage, agent_name: &str) -> Self

Convert from LlmUsage (terraphim_types) into an ExecutionRecord

Trait Implementations

impl Clone for ExecutionRecord

fn clone(&self) -> ExecutionRecord

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExecutionRecord

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExecutionRecord

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Persistable for ExecutionRecord

fn new(key: String) -> Self

Create a new instance

fn save<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Save to all profiles

fn save_to_one<'life0, 'life1, 'async_trait>( &'life0 self, profile_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save to a single profile

fn load<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load a key from the fastest operator

fn get_key(&self) -> String

fn load_config<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(HashMap<String, (Operator, u128)>, Operator), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Load the configuration

fn save_to_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Save to all profiles

fn save_to_profile<'life0, 'life1, 'async_trait>( &'life0 self, profile_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Save to a single profile

fn load_from_operator<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, _op: &'life2 Operator, ) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sized + Sync + 'async_trait,

Load from operators with fallback mechanism and cache warm-up

fn normalize_key(&self, key: &str) -> String

impl Serialize for ExecutionRecord

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.