Rust SDK

use meerkat_meta::{start_meta_runtime, DiscoverySpec, MetaConfig};
use std::time::Duration;

let config = MetaConfig {
    modules: vec![],
    discovery: DiscoverySpec {
        namespace: "my-app".into(),
        modules: vec![],
    },
    pre_spawn: vec![],
};

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

struct MetaConfig {
    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,
        payload: Option<Value>,
    },
    Module(ModuleEvent),
}

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

fn start_meta_runtime(
    config: MetaConfig,
    agent_events: Vec<EventEnvelope<UnifiedEvent>>,
    timeout: Duration,
) -> Result<MetaRuntimeHandle, MetaRuntimeError>

fn start_meta_runtime_with_options(
    config: MetaConfig,
    agent_events: Vec<EventEnvelope<UnifiedEvent>>,
    timeout: Duration,
    options: RuntimeOptions,
) -> Result<MetaRuntimeHandle, MetaRuntimeError>

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

use std::sync::Arc;
use meerkat_meta::{AgentMemoryConfig, SqliteAgentMemoryStore, UnifiedRuntime};

let memory = Arc::new(SqliteAgentMemoryStore::open(".meta/state/agent-memory")?);

let runtime = UnifiedRuntime::builder()
    .definition_path("config/mob.toml")
    .persistent_state(".meta/state")
    .roster_provider(roster_provider)
    .agent_memory(memory, AgentMemoryConfig::default())
    .build()
    .await?;

use meerkat_meta::{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?;
}

use meerkat_meta::{BootstrapCompletionRefused, UnifiedRuntime};

let runtime = UnifiedRuntime::builder()
    .definition_path("config/mob.toml")
    .persistent_state(".meta/state")
    .build()
    .await?;

let completion = runtime.take_bootstrap_completion()?;
match completion.publish(|| spawn_first_recovery_pass()) {
    Ok(_pass) => { /* the pass runs under the mob's ordinary admission */ }
    Err(BootstrapCompletionRefused::RuntimeClosing) => { /* the close began first */ }
    Err(_) => { /* AdmissionClosed: the mob's admission closed */ }
}

use meerkat_meta::UnifiedRuntime;
use std::sync::Arc;

let runtime = UnifiedRuntime::builder()
    .definition_path("config/mob.toml")
    .operation_refusal_observer(Arc::new(refusal_log)) // impl OperationRefusalObserver
    .build()
    .await?;

fn operation_review(
    &self,
    _construction: &GatewayFactoryConstruction<'_>,
) -> Result<Option<Arc<BoundOperationReview>>, GatewayHostError> {
    let review = BoundOperationReview::new(reviewer, approvals, deadline)
        .with_human_consent(consent_route, consent_validity);
    Ok(Some(Arc::new(review)))
}

from meerkat_meta import AgentCustomizerProtocol

class PassThrough(AgentCustomizerProtocol):
    async def customize_build(self, context, spec, draft) -> None:
        pass  # the host's wrapper adds what its members need

# Meta.builder() ... .agent_customizer(PassThrough()) ... .build()

let spec = spec.with_agent_customizer(customizer.clone());
let mut runtime = UnifiedRuntime::bootstrap(spec, meta_config, timeout).await?;
// ... compose the identity runtime and its context ...
runtime
    .install_and_bootstrap_identity_first_context(context, &roster)
    .await?;

use meerkat_meta::{MemberRestore, UnifiedRuntime};

let runtime = UnifiedRuntime::builder()
    .definition_path("config/mob.toml")
    .member_restore(MemberRestore::OnDemandVerified)
    .build()
    .await?;

use meerkat_core::ForkInstructionPolicy;
use meerkat_meta::UnifiedRuntime;

let runtime = UnifiedRuntime::builder()
    .definition_path("config/mob.toml")
    .fork_instruction_policy(ForkInstructionPolicy::ReactivateInherited)
    .build()
    .await?;

use meerkat::TokenStoreBackend;
use meerkat_meta::UnifiedRuntime;

let credentials = TokenStoreBackend::File {
    root: user_root.join("credentials"),
}
.open_with_refresh_authority()?;

let runtime = UnifiedRuntime::builder()
    .definition_path("config/mob.toml")
    .persistent_state(user_root.join("state"))
    .provider_auth_persistence(credentials)
    .build()
    .await?;

use async_trait::async_trait;
use meerkat_core::service::{CreateSessionRequest, SessionError};
use meerkat_meta::SessionHook;
use meerkat_runtime::mob_operator_authority::restrict_spawn_profiles_in_mob;

struct WorkersOnly;

#[async_trait]
impl SessionHook for WorkersOnly {
    async fn before_create(&self, req: &mut CreateSessionRequest) -> Result<(), SessionError> {
        let Some(build) = req.build.as_mut() else {
            return Ok(());
        };
        let Some(authority) = build.mob_tool_authority_context.as_ref() else {
            return Ok(());
        };
        if !authority.spawn_profile_scope().contains_key("my-mob") {
            return Ok(());
        }
        let narrowed = restrict_spawn_profiles_in_mob(authority, "my-mob", ["worker"])
            .map_err(SessionError::Unsupported)?;
        build.mob_tool_authority_context = Some(narrowed);
        Ok(())
    }
}

pub fn route_module_call(
    runtime: &MetaRuntimeHandle,
    request: &ModuleRouteRequest,
    timeout: Duration,
) -> Result<ModuleRouteResponse, ModuleRouteError>

pub fn route_module_call_rpc_json(
    runtime: &MetaRuntimeHandle,
    request_json: &str,
    timeout: Duration,
) -> Result<String, RpcRouteError>

fn validate_bigquery_naming(naming: &BigQueryNaming) -> Result<(), DecisionPolicyError>
fn load_trusted_meta_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 validate_trusted_oidc_runtime_config(config: &TrustedOidcRuntimeConfig) -> Result<(), DecisionPolicyError>
fn build_runtime_decision_state(input: RuntimeDecisionInputs) -> Result<RuntimeDecisionState, DecisionRuntimeError>
impl RuntimeDecisionState {
    // Explicit opt-out: a console that trusts no identity provider.
    fn local_console(console: ConsolePolicy, bigquery: Option<BigQueryNaming>) -> Self
    // Trusted module set for a local_console state (starts empty).
    fn with_modules(self, modules: Vec<ModuleConfig>) -> Self
}

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(file_name: &str, content: &str) -> Result<(), GovernanceValidationError>
fn validate_traceability_statuses(markdown: &str) -> Result<(), GovernanceValidationError>

// Decision state. Explicit opt-out for a local console that trusts no
// identity provider; ConsolePolicy::default() would require app auth and,
// with no trusted key, refuse every request.
let decisions = RuntimeDecisionState::local_console(
    ConsolePolicy { require_app_auth: false, ..ConsolePolicy::default() },
    None,
);
// Authenticated console: build_runtime_decision_state(RuntimeDecisionInputs { .. })?

// 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_without_runtime: Router = console_json_router(decisions.clone());
let json_api_with_runtime: Router =
    console_json_router_with_runtime(decisions, mob_runtime, None, None);

use meerkat_meta::gateway_composition::{
    validate_http_bind_policy, GatewaySurface, HttpBindPolicy,
};

validate_http_bind_policy(
    GatewaySurface::RpcGateway,
    addr,
    HttpBindPolicy::for_gateway(allow_remote, &decisions),
)?;