Struct RuntimeState 

pub struct RuntimeState {
    pub provider_capabilities: ProviderCapabilitySnapshot,
    pub processes: Vec<ManagedProcess>,
    pub timeline: Vec<RuntimeTimelineEvent>,
    pub builtin_tool_schema_tokens: usize,
    pub ollama_context: Option<OllamaContextInfo>,
    pub ollama_placement: Option<OllamaPlacement>,
    pub hinted_models: HashSet<String>,
    pub offload_warned: HashSet<String>,
    pub ollama_converged_num_ctx: HashMap<String, u32>,
    pub run_started: Option<SystemTime>,
    pub run_committed_tokens: usize,
    pub truncation_recoveries: u32,
}

Runtime state that is not part of the chat transcript sent to a model, but is useful for UI, slash commands, and debugging.

Fields

provider_capabilities: ProviderCapabilitySnapshot

processes: Vec<ManagedProcess>

timeline: Vec<RuntimeTimelineEvent>

builtin_tool_schema_tokens: usize

Estimated token cost of the built-in tool schemas the effect runner appends to every model request during dispatch. The reducer’s /context preview builds an MCP-only request and can’t see these, so the runner reports the figure via Msg::BuiltinToolSchemaTokens and /context folds it in to match what dispatch actually decides.

ollama_context: Option<OllamaContextInfo>

Resolved Ollama context window for the active model (None until the first turn probes it, or for non-Ollama providers).

ollama_placement: Option<OllamaPlacement>

Post-turn /api/ps memory placement for the active model (None until a turn probes it). Volatile, so it’s tracked separately from the window.

hinted_models: HashSet<String>

Models we’ve already shown the proactive auto-fit hint for this session. Session-only (not persisted) so the gentle reminder reappears each launch.

offload_warned: HashSet<String>

Models we’ve already warned about VRAM offload this session. Session-only, so the once-per-session warning behaves like the auto-fit hint.

ollama_converged_num_ctx: HashMap<String, u32>

Auto-converge: per-model num_ctx that the post-turn /api/ps check found fits VRAM, keyed by model id. Session-only (not persisted) because it depends on whatever else is using VRAM right now; re-derived each session. Read by build_chat_request below a user override.

run_started: Option<SystemTime>

When the current user interaction began. One “turn” in Mermaid is a single model call + its tools; an agentic run spans many such turns (each tool follow-up mints a fresh TurnId). This anchors the spinner’s elapsed timer to the whole run so it doesn’t reset to 0 at every tool step. Set on submit, read only while generating/executing tools. Session-only.

run_committed_tokens: usize

Estimated tokens generated in completed phases of the current run, so the spinner’s token counter accumulates across tool steps instead of resetting each model call. The live phase’s estimate is added on top at render time.

truncation_recoveries: u32

Consecutive auto-compact-and-continue recoveries in the current run after a context-window truncation. Bounded by settings.compaction.max_truncation_recoveries (0 = uncapped) and reset whenever the run makes progress, so it caps only no-progress thrashing on a too-small window. Session-only.

Implementations

impl RuntimeState

pub fn new(model_id: &str) -> Self

pub fn set_model(&mut self, model_id: &str)

pub fn record_signal(&mut self, signal: RuntimeSignal)

pub fn register_process(&mut self, process: ManagedProcess)

Trait Implementations

impl Clone for RuntimeState

fn clone(&self) -> RuntimeState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuntimeState

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

Formats the value using the given formatter.

impl Default for RuntimeState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RuntimeState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RuntimeState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.