Public declaration syntax from forge-rs/harness-runtime/src/spine/payloads.rs
Original source SHA-256: 5b7ac23fbe7abf6ed32c44c76757d9b11453d7b7acd4442a412e498dae519380
Function bodies and constant values are omitted. This is not the complete implementation.

Source line 29
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MindMemoryObject {
/// MIND protocol version the object conforms to.

pub mind_version: String,
/// UUID identifying the memory.

pub memory_id: String,
/// Core textual content.

pub content: String,
/// Provenance chain entries (opaque to the runtime).

#[serde(default)]
pub provenance_chain: Vec<Value>,
/// Access control rules (opaque to the runtime).

#[serde(default)]
pub access_control_list: Vec<Value>,
/// Annotations (opaque to the runtime).

#[serde(default)]
pub annotations: Vec<Value>,
/// Triggers (opaque to the runtime).

#[serde(default)]
pub triggers: Vec<Value>,
/// Object metadata (timestamp, source DID, tags).

pub metadata: MindMemoryMetadata
}

Source line 56
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MindMemoryMetadata {
/// RFC 3339 timestamp of the write.

pub timestamp: String,
/// DID of the agent the memory is attributed to.

pub source_agent_did: String,
/// Free-form tags.

#[serde(default)]
pub tags: Vec<String>,
/// Ontology references.

#[serde(default)]
pub ontology_references: Vec<String>
}

Source line 72
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MindSymbolicFilter {
/// Subject pattern.

#[serde(skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
/// Predicate pattern.

#[serde(skip_serializing_if = "Option::is_none")]
pub predicate: Option<String>,
/// Object pattern.

#[serde(skip_serializing_if = "Option::is_none")]
pub object: Option<String>
}

Source line 91
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MindMemoryQuery {
/// Caller-minted query id.

pub query_id: String,
/// Symbolic triple filter.

#[serde(skip_serializing_if = "Option::is_none")]
pub symbolic_filter: Option<MindSymbolicFilter>,
/// DID of the agent requesting recall (the spine tenant principal).

pub requesting_agent_did: String,
/// Result cap.

#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<usize>
}

Source line 107
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MindStorageResult {
/// The stored memory's id.

pub memory_id: String,
/// Store timestamp (provider-rendered).

pub stored_at: String,
/// Backend that stored the object (`LOCAL` | `AKASHA`).

pub backend: String,
/// Stored version.

pub version: u64
}

Source line 121
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MindQueryResult {
/// Echo of the query id.

pub query_id: String,
/// The recalled memory objects.

pub results: Vec<MindMemoryObject>,
/// Provider-measured execution time.

pub execution_time_ms: u64,
/// Provider message (may be empty).

pub message: String
}

Source line 142
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct MarcReasoningTask {
/// Caller-minted task id.

pub task_id: String,
/// Reasoning type (`"deductive"` for the context-plane projection).

pub reasoning_type: String,
/// Reasoning mode; the spine projection is always Monolithic.

pub mode: Value,
/// Premise statements. MARC's deductive engine rejects an empty

/// premise list (`InsufficientPremises`) — callers must supply at

/// least one real premise (recalled memory contents or the task

/// text); a fabricated premise would poison the trace.

pub premises: Vec<String>,
/// The query the engine evaluates.

pub query: String,
/// Optional context string.

#[serde(skip_serializing_if = "Option::is_none")]
pub context: Option<String>,
/// Engine parameters (provenance markers ride here).

pub engine_params: Value
}

Source line 166
pub fn deductive(
        task_id: impl Into<String>,
        premises: Vec<String>,
        query: impl Into<String>,
        context: Option<String>,
    ) -> Self;

Source line 191
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct MarcTaskResult {
/// Echo of the task id.

pub task_id: String,
/// The engine's result value.

pub result: Value,
/// Engine-reported confidence in `[0, 1]`.

pub confidence: f64,
/// The reasoning trace (steps, totals, timing).

pub reasoning_trace: Value,
/// Synthesis details, when the mode produced them.

#[serde(default)]
pub synthesis_details: Option<Value>,
/// Issues raised by the engine.

#[serde(default)]
pub issues: Vec<Value>
}