Rust SDK reference

pub fn new(base_url: Url, token: Option<String>, namespace: Option<Namespace>) -> Result<Self>

pub async fn post_json<T: Serialize, R: DeserializeOwned>(
        &self,
        path: &str,
        body: &T,
    ) -> Result<R>

pub async fn put_json<T: Serialize, R: DeserializeOwned>(
        &self,
        path: &str,
        body: &T,
    ) -> Result<R>

pub async fn patch_json<T: Serialize, R: DeserializeOwned>(
        &self,
        path: &str,
        body: &T,
    ) -> Result<R>

pub async fn delete_json<R: DeserializeOwned>(&self, path: &str) -> Result<R>

pub async fn get_json<R: DeserializeOwned>(&self, path: &str) -> Result<R>

pub async fn list_keyspaces(&self) -> Result<Vec<KeyspaceInfo>>

pub async fn create_keyspace(&self, name: &str, model: &str) -> Result<Value>

pub async fn import_domain_primitives(
        &self,
        keyspace: &str,
        records: &[Value],
        schema_version: Option<u32>,
        upsert: bool,
    ) -> Result<Value>

pub async fn export_domain_primitives(
        &self,
        keyspace: &str,
        schema_version: Option<u32>,
    ) -> Result<Value>

pub async fn backup_create(&self, backup_dir: &str, options: Option<Value>) -> Result<Value>

pub async fn backup_list(&self, backup_dir: &str) -> Result<Value>

pub async fn backup_delete(&self, backup_dir: &str, id: &str) -> Result<Value>

pub async fn backup_restore(
        &self,
        backup_dir: &str,
        id: &str,
        options: Option<Value>,
    ) -> Result<Value>

pub async fn kv_health(&self) -> Result<Value>

pub async fn kv_consistency(&self) -> Result<Value>

pub async fn storage_volume_create(&self, payload: &Value) -> Result<Value>

pub async fn storage_volume_list(&self) -> Result<Value>

pub async fn storage_volume_attach(&self, payload: &Value) -> Result<Value>

pub async fn storage_volume_detach(&self, payload: &Value) -> Result<Value>

pub async fn storage_volume_delete(&self, volume_id: &str) -> Result<Value>

pub async fn stats(&self) -> Result<Value>

pub async fn cypher<T: for<'de> Deserialize<'de>>(&self, query: &str) -> Result<Vec<T>>

pub async fn text_search(&self, q: &str, limit: usize) -> Result<Vec<Value>>

pub async fn ensure_property_index(&self, property: &str) -> Result<Value>

pub async fn index_stats(&self) -> Result<Value>

pub async fn pagerank(&self, damping_factor: Option<f64>) -> Result<Value>

pub async fn shortest_path(&self, source: &str, target: &str) -> Result<Value>

pub async fn connected_components(&self, strong: bool) -> Result<Value>

pub async fn microtheory_switch(&self, name: &str) -> Result<Value>

pub async fn microtheory_keyspace(&self, name: &str) -> Result<Value>

pub async fn schema_metadata(&self) -> Result<Value>

pub async fn sql(&self, query: &str) -> Result<Vec<Value>>

pub async fn register_csv(&self, name: &str, path: &str) -> Result<Value>

pub async fn register_parquet(&self, name: &str, path: &str) -> Result<Value>

pub async fn options(&self, opts: &Value) -> Result<Value>

pub async fn cache_clear(&self) -> Result<Value>

pub async fn cache_stats(&self) -> Result<Value>

pub async fn embed(&self, text: &str) -> Result<Vec<f32>>

pub async fn generate(
        &self,
        model_id: &str,
        prompt: &str,
        max_tokens: usize,
        temperature: f32,
    ) -> Result<String>

pub async fn models(&self) -> Result<Vec<String>>

pub async fn load_model_from_path(
        &self,
        name: &str,
        model_type: &str,
        framework: &str,
        path: &str,
    ) -> Result<String>

pub async fn load_model_from_b64(
        &self,
        name: &str,
        model_type: &str,
        framework: &str,
        data_b64: &str,
    ) -> Result<String>

pub async fn unload_model(&self, id: &str) -> Result<Value>

pub async fn vector_create(&self, name: &str, dims: usize, metric: &str) -> Result<Value>

pub async fn vector_add(&self, name: &str, id: &str, vector: &[f32]) -> Result<Value>

pub async fn vector_search(&self, name: &str, vector: &[f32], k: usize) -> Result<Value>

pub async fn vector_save(&self, name: &str) -> Result<Value>

pub async fn vector_list(&self) -> Result<Value>

pub async fn metrics(&self, model_id: &str) -> Result<Value>

pub fn generate_stream(
        &self,
        model_id: String,
        prompt: String,
        max_tokens: usize,
        temperature: f32,
    ) -> impl Stream<Item = Result<String>> + '_

pub async fn search(&self, q: &str, limit: usize) -> Result<Vec<Value>>

pub async fn episodic_delete(&self, id: &str) -> Result<Value>

pub async fn episodic_store(&self, raw_from: &str, tags: Option<&[String]>) -> Result<Value>

pub async fn retrieval_hybrid(&self, text: &str, limit: Option<usize>) -> Result<Value>

pub async fn vault_search(&self, pattern: &str) -> Result<Value>

pub async fn vault_get(&self, id: &str) -> Result<Value>

pub async fn vault_delete(&self, id: &str) -> Result<Value>

pub async fn vault_stats(&self) -> Result<Value>

pub async fn new_network(&self, config: &Value) -> Result<Value>

pub async fn store(&self, id: &str, vector: &[f32]) -> Result<Value>

pub async fn retrieve_by_key(&self, id: &str) -> Result<Value>

pub async fn retrieve_by_vector(&self, vector: &[f32], k: usize) -> Result<Value>

pub async fn clear(&self) -> Result<Value>

pub async fn stats(&self) -> Result<Value>

pub async fn config(&self) -> Result<Value>

pub async fn system_info(&self) -> Result<Value>

pub async fn new_network_typed(
        &self,
        req: &v1::mhn::NewRequest,
    ) -> Result<v1::mhn::NewResponse>

pub async fn store_typed(&self, req: &v1::mhn::StoreRequest) -> Result<v1::mhn::StoreResponse>

pub async fn retrieve_by_key_typed(
        &self,
        req: &v1::mhn::RetrieveByKeyRequest,
    ) -> Result<v1::mhn::RetrieveResponse>

pub async fn retrieve_by_vector_typed(
        &self,
        req: &v1::mhn::RetrieveByVectorRequest,
    ) -> Result<v1::mhn::NeighborsResponse>

pub async fn clear_typed(&self) -> Result<v1::mhn::ClearResponse>

pub async fn stats_typed(&self) -> Result<v1::mhn::StatsResponse>

pub async fn config_typed(&self) -> Result<v1::mhn::ConfigResponse>

pub async fn system_info_typed(&self) -> Result<v1::mhn::SystemInfoResponse>

pub async fn thought(&self, thought: &Value) -> Result<Value>

pub async fn decision(&self, decision: &Value) -> Result<Value>

pub async fn interaction(&self, interaction: &Value) -> Result<Value>

pub async fn session(&self, req: &Value) -> Result<Value>

pub async fn session_update(&self, req: &Value) -> Result<Value>

pub async fn query(&self, req: &Value) -> Result<Value>

pub async fn decision_trace(&self, id: &str) -> Result<Value>

pub async fn thought_typed(
        &self,
        thought: &v1::cognitive::CognitiveThought,
    ) -> Result<v1::cognitive::IdResponse>

pub async fn decision_typed(
        &self,
        decision: &v1::cognitive::CognitiveDecision,
    ) -> Result<v1::cognitive::IdResponse>

pub async fn interaction_typed(
        &self,
        interaction: &v1::cognitive::AgentInteraction,
    ) -> Result<v1::cognitive::IdResponse>

pub async fn session_typed(
        &self,
        agent_id: &str,
        goal: &str,
    ) -> Result<v1::cognitive::SessionStartResponse>

pub async fn session_update_typed(
        &self,
        session: &v1::cognitive::CognitiveSession,
    ) -> Result<serde_json::Value>

pub async fn query_typed(
        &self,
        query: &v1::cognitive::CognitiveQuery,
    ) -> Result<v1::cognitive::QueryResponse>

pub async fn decision_trace_typed(
        &self,
        id: &str,
    ) -> Result<v1::cognitive::DecisionTraceResponse>

pub async fn start(&self) -> Result<Value>

pub async fn stop(&self) -> Result<Value>

pub async fn metrics(&self) -> Result<Value>

pub async fn reinforce(
        &self,
        trace_id: &str,
        value: f32,
        source: Option<&str>,
    ) -> Result<Value>

pub async fn experience(&self, content: &str, context: Option<&str>) -> Result<Value>

pub async fn start_typed(&self) -> Result<v1::cycle::StartResponse>

pub async fn stop_typed(&self) -> Result<v1::cycle::StopResponse>

pub async fn metrics_typed(&self) -> Result<v1::cycle::MetricsResponse>

pub async fn reinforce_typed(
        &self,
        trace_id: &str,
        value: f32,
        source: Option<&str>,
    ) -> Result<v1::cycle::OkResponse>

pub async fn experience_typed(
        &self,
        content: &str,
        context: Option<&str>,
    ) -> Result<v1::cycle::ExperienceResponse>

pub async fn checkpoints(&self, req: &Value) -> Result<Value>

pub async fn checkpoints_status(&self) -> Result<Value>

pub async fn recover(&self, req: &Value) -> Result<Value>

pub async fn components(&self, req: &Value) -> Result<Value>

pub async fn delete_component(&self, id: &str) -> Result<Value>

pub async fn network_build(&self, req: &Value) -> Result<Value>

pub async fn network_compile(&self, req: &Value) -> Result<Value>

pub async fn network_step(&self, req: &Value) -> Result<Value>

pub async fn train_bptt(&self, req: &Value) -> Result<Value>

pub async fn network_state(&self, req: &Value) -> Result<Value>

pub async fn federation_agent_update(&self, req: &Value) -> Result<Value>

pub async fn federation_agent_remove(&self, req: &Value) -> Result<Value>

pub async fn federation_recent_spikes(&self, req: &Value) -> Result<Value>

pub async fn retrieve(&self, req: &Value) -> Result<Value>

pub async fn retrieve_with_mode(&self, req: &Value) -> Result<Value>

pub async fn paths_find(&self, req: &Value) -> Result<Value>

pub async fn prefetch_start(&self, req: &Value) -> Result<Value>

pub async fn prefetch_stop(&self, req: &Value) -> Result<Value>

pub async fn cache_stats(&self) -> Result<Value>

pub async fn cb_execute(&self, name: &str, req: &Value) -> Result<Value>

        pub struct CognitiveThought {
            pub id: uuid::Uuid,
            pub agent_id: String,
            pub timestamp: chrono::DateTime<chrono::Utc>,
            pub thought_type: ThoughtType,
            pub content: String,
            pub confidence: f32,
            pub parent_thought_id: Option<uuid::Uuid>,
            pub context: HashMap<String, serde_json::Value>,
            pub tags: Vec<String>,
        }

        pub enum ThoughtType {
            ProblemAnalysis,
            Hypothesis,
            EvidenceEvaluation,
            Reasoning,
            Decision,
            Planning,
            Reflection,
            ErrorDetection,
            Learning,
            Communication,
        }

        pub struct DecisionOption {
            pub option: String,
            pub pros: Vec<String>,
            pub cons: Vec<String>,
            pub score: f32,
            pub rejected_reason: Option<String>,
        }

        pub struct CognitiveDecision {
            pub id: uuid::Uuid,
            pub agent_id: String,
            pub timestamp: chrono::DateTime<chrono::Utc>,
            pub decision: String,
            pub options_considered: Vec<DecisionOption>,
            pub reasoning_trace: Vec<uuid::Uuid>,
            pub confidence: f32,
            pub expected_outcomes: Vec<String>,
            pub actual_outcomes: Option<Vec<String>>,
        }

        pub enum InteractionType {
            Query,
            Request,
            Inform,
            Delegate,
            Collaborate,
            Negotiate,
            Conflict,
            Consensus,
        }

        pub struct InteractionResponse {
            pub timestamp: chrono::DateTime<chrono::Utc>,
            pub response: String,
            pub success: bool,
            pub metadata: HashMap<String, serde_json::Value>,
        }

        pub struct AgentInteraction {
            pub id: uuid::Uuid,
            pub timestamp: chrono::DateTime<chrono::Utc>,
            pub from_agent: String,
            pub to_agent: String,
            pub interaction_type: InteractionType,
            pub message: String,
            pub context: HashMap<String, serde_json::Value>,
            pub response: Option<InteractionResponse>,
        }

        pub struct CognitiveSession {
            pub id: uuid::Uuid,
            pub agent_id: String,
            pub start_time: chrono::DateTime<chrono::Utc>,
            pub end_time: Option<chrono::DateTime<chrono::Utc>>,
            pub goal: String,
            pub thoughts: Vec<uuid::Uuid>,
            pub decisions: Vec<uuid::Uuid>,
            pub interactions: Vec<uuid::Uuid>,
            pub outcome: Option<SessionOutcome>,
            pub metadata: HashMap<String, serde_json::Value>,
        }

        pub struct SessionOutcome {
            pub success: bool,
            pub result: String,
            pub learnings: Vec<String>,
            pub follow_up_required: bool,
        }

        pub struct CognitiveQuery {
            pub agent_id: Option<String>,
            pub start_time: Option<chrono::DateTime<chrono::Utc>>,
            pub end_time: Option<chrono::DateTime<chrono::Utc>>,
            pub min_confidence: Option<f32>,
            pub include_thoughts: bool,
            pub include_decisions: bool,
            pub include_interactions: bool,
            pub include_sessions: bool,
        }

        pub struct IdResponse {
            pub id: String,
        }

        pub struct SessionStartResponse {
            pub session: CognitiveSession,
        }

        pub struct QueryResponse {
            pub thoughts: usize,
            pub decisions: usize,
            pub interactions: usize,
            pub sessions: usize,
        }

        pub struct DecisionTraceResponse {
            pub length: usize,
        }

        pub struct StartResponse {
            pub running: bool,
        }

        pub struct StopResponse {
            pub stopped: bool,
        }

        pub struct OkResponse {
            pub ok: bool,
        }

        pub struct ExperienceResponse {
            pub trace_id: String,
            pub action: String,
        }

        pub struct StageStats {
            pub count: u64,
            pub mean_ms: f64,
            pub std_dev_ms: f64,
            pub min_ms: f64,
            pub max_ms: f64,
        }

        pub struct MetricsResponse {
            pub broadcasts_total: u64,
            pub broadcast_send_failures_total: u64,
            pub receiver_lag_total: u64,
            pub receivers_current: u64,
            pub signals_cache_len: u64,
            pub stage_stats: Vec<StageStats>,
            pub reward: RewardStats,
        }

        pub struct RewardStats {
            pub count: u64,
            pub mean: f64,
            pub std_dev: f64,
            pub min: f64,
            pub max: f64,
        }

        pub struct NewRequest {
            pub dimensions: usize,
        }

        pub struct NewResponse {
            pub ok: bool,
            pub dims: usize,
        }

        pub struct StoreRequest {
            pub id: String,
            pub vector: Vec<f32>,
        }

        pub struct StoreResponse {
            pub id: String,
        }

        pub struct RetrieveByKeyRequest {
            pub id: String,
        }

        pub struct RetrieveByVectorRequest {
            pub vector: Vec<f32>,
            pub k: Option<usize>,
        }

        pub struct RetrieveResponse {
            pub id: String,
            pub embedding: Vec<f32>,
        }

        pub struct Neighbor {
            pub id: String,
            pub score: f64,
        }

        pub struct NeighborsResponse {
            pub neighbors: Vec<Neighbor>,
        }

        pub struct ClearResponse {
            pub ok: bool,
        }

        pub struct StatsResponse {
            pub count: usize,
        }

        pub struct ConfigResponse {
            pub dimensions: Option<usize>,
            pub persistence: bool,
        }

        pub struct SystemInfoResponse {
            pub dimensions: Option<usize>,
            pub count: usize,
            pub capacity_estimate: Option<usize>,
            pub load_factor: f64,
        }

pub struct AkashaClient {
    http: Http,
    pub core: CoreClient,
    pub graph: GraphClient,
    pub analytics: AnalyticsClient,
    pub ml: MlClient,
    pub memory: MemoryClient,
    pub continual: ContinualClient,
    pub snn: SnnClient,
    pub neurosymbolic: NeuroSymbolicClient,
    pub assoc_mhn: AssocMhnClient,
    pub cognitive: CognitiveClient,
    pub cycle: CycleClient,
}

pub struct CoreClient {
    http: Http,
}

pub struct KeyspaceInfo {
    pub name: String,
    pub model: String,
}

pub struct GraphClient {
    http: Http,
}

pub struct AnalyticsClient {
    http: Http,
}

pub struct MlClient {
    http: Http,
}

pub struct ModelInfo {
    pub id: String,
    pub name: String,
    pub framework: String,
}

pub struct MemoryClient {
    http: Http,
}

pub struct AssocMhnClient {
    http: Http,
}

pub struct CognitiveClient {
    http: Http,
}

pub struct CycleClient {
    http: Http,
}

pub struct ContinualClient {
    http: Http,
}

pub struct SnnClient {
    http: Http,
}

pub struct SnnBuildRequest {
    pub namespace: String,
    pub network_id: Option<String>,
    pub version: Option<String>,
    pub spec: serde_json::Value,
    pub actions: Vec<String>,
    pub capability: CapabilityTokenPayload,
}

pub struct SnnCompileRequest {
    pub namespace: String,
    pub network_id: String,
    pub version: Option<String>,
    pub actions: Vec<String>,
    pub capability: CapabilityTokenPayload,
}

pub struct SnnStepRequest {
    pub namespace: String,
    pub network_id: String,
    pub version: Option<String>,
    pub input: Vec<f32>,
    pub actions: Vec<String>,
    pub capability: CapabilityTokenPayload,
}

pub struct SnnTrainRequest {
    pub namespace: String,
    pub network_id: String,
    pub version: Option<String>,
    pub steps: usize,
    pub actions: Vec<String>,
    #[serde(flatten)]
    pub capability: CapabilityTokenPayload,
}

pub struct SnnStateRequest {
    pub namespace: String,
    pub actions: Vec<String>,
    pub capability: CapabilityTokenPayload,
}

pub struct NeuroSymbolicClient {
    http: Http,
}

pub mod v1 {

    /// Cognitive API types
    pub mod cognitive {
        use serde::{Deserialize, Serialize};

    pub mod cycle {
        use serde::{Deserialize, Serialize};

    pub mod mhn {
        use serde::{Deserialize, Serialize};

pub fn new(api_key: impl Into<String>) -> Result<Self>

pub fn staging(api_key: impl Into<String>) -> Result<Self>

pub fn with_base_url(mut self, url: impl AsRef<str>) -> Result<Self>

pub fn with_timeout(mut self, timeout: Duration) -> Self

pub async fn list(&self, query: Option<&ListTenantsQuery>) -> Result<ListTenantsResponse>

pub async fn create(&self, request: &CreateTenantRequest) -> Result<CreateTenantResponse>

pub async fn get(&self, tenant_id: &str) -> Result<Tenant>

pub async fn update(
        &self,
        tenant_id: &str,
        request: &UpdateTenantRequest,
    ) -> Result<UpdateTenantResponse>

pub async fn delete(&self, tenant_id: &str, force: bool) -> Result<DeleteTenantResponse>

pub async fn status(&self, tenant_id: &str) -> Result<TenantStatusResponse>

pub async fn scale(&self, tenant_id: &str, request: &ScaleRequest) -> Result<ScaleResponse>

pub async fn generate_token(&self, tenant_id: &str) -> Result<GenerateTokenResponse>

pub async fn list(&self, tenant_id: &str) -> Result<ListBackupsResponse>

pub async fn create(
        &self,
        tenant_id: &str,
        request: Option<&CreateBackupRequest>,
    ) -> Result<CreateBackupResponse>

pub async fn get(&self, tenant_id: &str, backup_id: &str) -> Result<Backup>

pub async fn restore(
        &self,
        tenant_id: &str,
        backup_id: &str,
        request: Option<&RestoreBackupRequest>,
    ) -> Result<RestoreBackupResponse>

pub async fn delete(&self, tenant_id: &str, backup_id: &str) -> Result<()>