Struct Runtime 

pub struct Runtime {
    pub store: Store,
    pub skills: Vec<Skill>,
    pub projects: Vec<Project>,
    pub data_dir: String,
    pub system_prompt: String,
    pub channel: String,
    pub project: Option<String>,
    pub hook_runner: Arc<dyn HookRunner>,
    pub permission_rules: Option<Arc<PermissionRules>>,
}

A configured Kernex runtime with all subsystems initialized.

Fields

store: Store

Persistent memory store.

skills: Vec<Skill>

Loaded skills from the data directory.

projects: Vec<Project>

Loaded projects from the data directory.

data_dir: String

Data directory path (expanded).

system_prompt: String

Base system prompt prepended to every request.

channel: String

Communication channel identifier (e.g. “cli”, “api”, “slack”).

project: Option<String>

Active project key for scoping memory and lessons.

hook_runner: Arc<dyn HookRunner>

Hook runner for tool lifecycle events.

permission_rules: Option<Arc<PermissionRules>>

Declarative allow/deny rules applied before each tool call.

Implementations

impl Runtime

pub async fn complete( &self, provider: &dyn Provider, request: &Request, ) -> Result<Response, KernexError>

Send a request through the full runtime pipeline: build context from memory → enrich with skills → complete via provider → save exchange.

This is the high-level convenience method that wires together all Kernex subsystems in a single call.

pub async fn complete_with_needs( &self, provider: &dyn Provider, request: &Request, needs: &ContextNeeds, ) -> Result<Response, KernexError>

Like complete, but with explicit control over which context blocks are loaded from memory.

pub async fn run( &self, provider: &dyn Provider, request: &Request, config: &RunConfig, ) -> Result<RunOutcome, KernexError>

Run the agent with explicit lifecycle control.

Sets max_turns in context so the provider’s agentic loop respects it, wires the runtime hook runner, calls the provider, fires the on_stop hook, and wraps the outcome in RunOutcome.