Struct SessionAsset 

pub struct SessionAsset {
    pub id: String,
    pub version: u32,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
    pub history: ConversationHistory,
    pub preferences: UserPreferences,
    pub project_context: ProjectContext,
    pub skill_configs: HashMap<String, SkillConfig>,
    pub component_snapshots: HashMap<String, ComponentSnapshot>,
    pub granted_commands: Vec<CommandGrant>,
    pub metadata: HashMap<String, Value>,
}

SessionAsset - The accumulating value.

This is the core data structure that persists between sessions. It contains all the context and history that makes the assistant more useful over time.

Example

use orcs_runtime::session::SessionAsset;

let mut asset = SessionAsset::new();
asset.project_context.name = Some("my-project".into());

// Save to JSON
let json = asset.to_json().expect("asset should serialize to JSON");

Fields

id: String

Asset ID (UUID).

version: u32

Session version for compatibility.

created_at_ms: u64

Creation timestamp (milliseconds since epoch).

updated_at_ms: u64

Last update timestamp (milliseconds since epoch).

history: ConversationHistory

Conversation history.

preferences: UserPreferences

User preferences.

project_context: ProjectContext

Project context.

skill_configs: HashMap<String, SkillConfig>

Skill configurations.

component_snapshots: HashMap<String, ComponentSnapshot>

Component snapshots for resume.

granted_commands: Vec<CommandGrant>

Granted command patterns (restored on session resume).

These are the commands that were approved via HIL during previous sessions. On resume, they are restored into the GrantPolicy so the user doesn’t need to re-approve the same commands.

metadata: HashMap<String, Value>

Arbitrary metadata.

Implementations

impl SessionAsset

pub fn new() -> Self

Creates a new session asset with a fresh UUID.

pub fn for_project(path: impl Into<PathBuf>) -> Self

Creates a session asset for a specific project.

pub fn touch(&mut self)

Updates the modification timestamp.

pub fn add_turn(&mut self, turn: ConversationTurn)

Adds a conversation turn.

pub fn set_skill_config( &mut self, skill_id: impl Into<String>, config: SkillConfig, )

Updates a skill configuration.

pub fn save_snapshot(&mut self, snapshot: ComponentSnapshot)

Saves a component snapshot.

pub fn get_snapshot(&self, fqn: &str) -> Option<&ComponentSnapshot>

Retrieves a component snapshot by FQN.

pub fn remove_snapshot(&mut self, fqn: &str) -> Option<ComponentSnapshot>

Removes a component snapshot by FQN.

pub fn clear_snapshots(&mut self)

Clears all component snapshots.

pub fn snapshot_count(&self) -> usize

Returns the number of saved snapshots.

pub fn save_grants(&mut self, grants: Vec<CommandGrant>)

Saves granted commands (replaces existing).

Call this before persisting the session to capture the current grant state from a GrantPolicy.

pub fn granted_commands(&self) -> &[CommandGrant]

Returns the saved granted commands.

pub fn grant_count(&self) -> usize

Returns the number of saved grants.

pub fn created_at(&self) -> DateTime<Utc>

Returns the creation time as a DateTime.

pub fn updated_at(&self) -> DateTime<Utc>

Returns the update time as a DateTime.

pub fn to_json(&self) -> Result<String, Error>

Serializes to JSON.

pub fn from_json(json: &str) -> Result<Self, Error>

Deserializes from JSON.

pub fn checksum(&self) -> String

Calculates a checksum for integrity verification.

Trait Implementations

impl Clone for SessionAsset

fn clone(&self) -> SessionAsset

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SessionAsset

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

Formats the value using the given formatter.

impl Default for SessionAsset

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SessionAsset

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SessionAsset

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

where __S: Serializer,

Serialize this value into the given Serde serializer.