Rust SDK

use meerkat_mobkit::{
    start_mobkit_runtime, MobKitConfig, ModuleConfig,
    DiscoverySpec, RestartPolicy,
};
use std::time::Duration;

let config = MobKitConfig {
    modules: vec![
        ModuleConfig {
            id: "router".into(),
            command: "meerkat-router".into(),
            args: vec![],
            restart_policy: RestartPolicy::OnFailure,
        },
    ],
    discovery: DiscoverySpec {
        namespace: "my-app".into(),
        modules: vec!["router".into()],
    },
    pre_spawn: vec![],
};

let runtime = start_mobkit_runtime(config, vec![], Duration::from_secs(30))?;

struct MobKitConfig {
    modules: Vec<ModuleConfig>,
    discovery: DiscoverySpec,
    pre_spawn: Vec<PreSpawnData>,
}

struct ModuleConfig {
    id: String,
    command: String,
    args: Vec<String>,
    restart_policy: RestartPolicy,
}

struct EventEnvelope<T> {
    event_id: String,
    source: String,
    timestamp_ms: u64,
    event: T,
}

enum UnifiedEvent {
    Agent { agent_id: String, event_type: String },
    Module(ModuleEvent),
}

struct ModuleEvent {
    module: String,
    event_type: String,
    payload: Value,
}

fn start_mobkit_runtime(
    config: MobKitConfig,
    agent_events: Vec<EventEnvelope<UnifiedEvent>>,
    timeout: Duration,
) -> Result<MobkitRuntimeHandle, MobkitRuntimeError>

fn start_mobkit_runtime_with_options(
    config: MobKitConfig,
    agent_events: Vec<EventEnvelope<UnifiedEvent>>,
    timeout: Duration,
    options: RuntimeOptions,
) -> Result<MobkitRuntimeHandle, MobkitRuntimeError>

UnifiedRuntime::builder()
    .mob_spec(spec)
    .module_config(config)
    .timeout(duration)
    .build()
    .await?

use meerkat_mobkit::{AgentMemoryConfig, UnifiedRuntime};

let runtime = UnifiedRuntime::builder()
    .persistent_state(".mobkit/state")
    .roster_provider(roster_provider)
    .persistent_agent_memory(AgentMemoryConfig::default())
    .build()
    .await?;

use meerkat_mobkit::{AgentMemoryRecallRequest, AgentMemorySelection, NewAgentMemory};

let record = runtime
    .remember_agent_memory(
        "default",
        &identity,
        NewAgentMemory {
            title: "Deployment preference".into(),
            body: "Use the staging realm before production deploys.".into(),
            tags: vec!["deploy".into()],
        },
    )
    .await?;

let records = runtime
    .recall_agent_memory(AgentMemoryRecallRequest {
        identity: identity.clone(),
        realm: "default".into(),
        selection: AgentMemorySelection::Contextual,
        query_text: Some("What should I check before deploying?".into()),
        query_terms: vec!["deploy".into()],
        max_entries: 4,
    })
    .await?;

if let Some(record) = records.first() {
    runtime
        .forget_agent_memory("default", &identity, &record.memory_id)
        .await?;
}

fn route_module_call(
    handle: &MobkitRuntimeHandle,
    request: ModuleRouteRequest,
) -> Result<ModuleRouteResponse, ModuleRouteError>

fn route_module_call_rpc_json(
    request: &JsonRpcRequest,
) -> Result<JsonRpcResponse, RpcRouteError>

fn evaluate_schedules_at_tick(
    schedules: &[ScheduleDefinition],
    tick_ms: u64,
) -> Result<ScheduleEvaluation, ScheduleValidationError>

fn validate_bigquery_naming(naming: &BigQueryNaming) -> Result<(), DecisionPolicyError>
fn load_trusted_mobkit_modules_from_toml(toml: &str) -> Result<Vec<ModuleConfig>, DecisionPolicyError>
fn enforce_console_route_access(auth: &AuthPolicy, console: &ConsolePolicy, req: &ConsoleAccessRequest) -> Result<(), DecisionPolicyError>
fn validate_runtime_ops_policy(policy: &RuntimeOpsPolicy) -> Result<(), DecisionPolicyError>

fn inspect_jwt_header(token: &str) -> Result<JwtHeaderView, JwtValidationError>
fn validate_jwt_locally(token: &str, config: &JwtValidationConfig) -> Result<ValidatedJwt, JwtValidationError>
fn parse_oidc_discovery_json(json: &str) -> Result<OidcDiscoveryDocument, OidcContractError>
fn parse_jwks_json(json: &str) -> Result<JwksDocument, OidcContractError>

fn validate_governance_state(state: &str) -> Result<(), GovernanceValidationError>
fn validate_traceability_statuses(statuses: &[&str]) -> Result<(), GovernanceValidationError>

// Console frontend (HTML + JS + CSS)
let frontend: Router = console_frontend_router();

// Console JSON API, JSON-RPC, timeline SSE, multipart upload/send, and blobs
let json_api: Router = console_json_router(decisions);
let json_api: Router = console_json_router_with_runtime(decisions, mob_runtime);