# Vault

Every registered vault instance operation, with source-derived inputs, outputs, access policy, and errors.

Source: https://docs.minds.sh/docs/api/instance/vault



This reference covers **7 HTTP operations** registered by the Akasha daemon. Call these paths on your instance base URL. See [authentication](/docs/api/instance/authentication), [errors](/docs/api/instance/errors), and [coverage](/docs/api/instance/coverage) before integrating.

| Method | Path                          | Operation                                            |
| ------ | ----------------------------- | ---------------------------------------------------- |
| `POST` | `/v1/memory/vault`            | [Memory vault store](#post-v1-memory-vault)          |
| `POST` | `/v1/memory/vault/get`        | [Vault get](#post-v1-memory-vault-get)               |
| `POST` | `/v1/memory/vault/delete`     | [Vault delete](#post-v1-memory-vault-delete)         |
| `POST` | `/v1/memory/vault/search`     | [Vault search](#post-v1-memory-vault-search)         |
| `GET`  | `/v1/memory/vault/stats`      | [Vault stats](#get-v1-memory-vault-stats)            |
| `POST` | `/v1/memory/vault/update`     | [Vault update](#post-v1-memory-vault-update)         |
| `POST` | `/v1/memory/vault/access-log` | [Vault access log](#post-v1-memory-vault-access-log) |

<a id="post-v1-memory-vault" />

## POST `/v1/memory/vault` [#post-v1memoryvault]

Memory vault store

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request]

**Json** — `VaultStoreRequest`

| Field         | Rust type | Required on input | Notes |
| ------------- | --------- | ----------------- | ----- |
| `key`         | `String`  | Yes               |       |
| `data_b64`    | `String`  | Yes               |       |
| `sensitivity` | `String`  | Yes               |       |

```rust
struct VaultStoreRequest {
    key: String,
    data_b64: String,
    sensitivity: String,
}
```

### Response [#response]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"id": id})
```

### Errors and validation [#errors-and-validation]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn memory_vault_store(
        State(state): State<AppState>,
        Extension(authority): Extension<RequestAuthority>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<VaultStoreRequest>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        state.usage_emitter.emit_cognitive_op("memory");
        let data = base64::engine::general_purpose::STANDARD
            .decode(req.data_b64.as_bytes())
            .map_err(|e| DaemonError::InvalidRequest(format!("bad base64: {e}")))?;
        let level = match req.sensitivity.as_str() {
            "public" => VaultSensitivity::Public,
            "internal" => VaultSensitivity::Internal,
            "confidential" => VaultSensitivity::Confidential,
            "secret" => VaultSensitivity::Secret,
            "topsecret" | "top_secret" => VaultSensitivity::TopSecret,
            "high" => VaultSensitivity::High,
            _ => VaultSensitivity::Internal,
        };
        let ctx = vault_user_context(&authority, "vault:write");
        let id = db
            .vault_store(req.key, &data, level, &ctx)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"id": id})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:7575`. Registration: `akasha-daemon/src/main.rs:4660`.

<a id="post-v1-memory-vault-get" />

## POST `/v1/memory/vault/get` [#post-v1memoryvaultget]

Vault get

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-1]

**Json** — `VaultGetReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct VaultGetReq {
    id: String,
}
```

### Response [#response-1]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"entry": entry.map(|e| format!("{e:?}"))}),
```

### Errors and validation [#errors-and-validation-1]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn vault_get(
        State(state): State<AppState>,
        Extension(authority): Extension<RequestAuthority>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<VaultGetReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let id = uuid::Uuid::parse_str(&req.id)
            .map_err(|_| DaemonError::InvalidRequest("invalid id".into()))?;
        let ctx = vault_user_context(&authority, "vault:read");
        let entry = db
            .vault_get(&id, &ctx)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(
            serde_json::json!({"entry": entry.map(|e| format!("{e:?}"))}),
        ))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3783`. Registration: `akasha-daemon/src/main.rs:4661`.

<a id="post-v1-memory-vault-delete" />

## POST `/v1/memory/vault/delete` [#post-v1memoryvaultdelete]

Vault delete

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-2]

**Json** — `VaultDeleteReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct VaultDeleteReq {
    id: String,
}
```

### Response [#response-2]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"ok": true})
```

### Errors and validation [#errors-and-validation-2]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn vault_delete(
        State(state): State<AppState>,
        Extension(authority): Extension<RequestAuthority>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<VaultDeleteReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let id = uuid::Uuid::parse_str(&req.id)
            .map_err(|_| DaemonError::InvalidRequest("invalid id".into()))?;
        let ctx = vault_user_context(&authority, "vault:delete");
        db.vault_delete(&id, &ctx)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3807`. Registration: `akasha-daemon/src/main.rs:4662`.

<a id="post-v1-memory-vault-search" />

## POST `/v1/memory/vault/search` [#post-v1memoryvaultsearch]

Vault search

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-3]

**Json** — `VaultSearchReq`

| Field     | Rust type | Required on input | Notes |
| --------- | --------- | ----------------- | ----- |
| `pattern` | `String`  | Yes               |       |

```rust
struct VaultSearchReq {
    pattern: String,
}
```

### Response [#response-3]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"entries": list.len()})
```

### Errors and validation [#errors-and-validation-3]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn vault_search(
        State(state): State<AppState>,
        Extension(authority): Extension<RequestAuthority>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<VaultSearchReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let ctx = vault_user_context(&authority, "vault:read");
        let list = db
            .vault_search(&req.pattern, &ctx, None)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"entries": list.len()})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3828`. Registration: `akasha-daemon/src/main.rs:4663`.

<a id="get-v1-memory-vault-stats" />

## GET `/v1/memory/vault/stats` [#get-v1memoryvaultstats]

Vault stats

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-4]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-4]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(stats).unwrap_or(serde_json::json!({})),
```

### Errors and validation [#errors-and-validation-4]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn vault_stats(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let stats = db
            .vault_stats()
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(
            serde_json::to_value(stats).unwrap_or(serde_json::json!({})),
        ))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:7644`. Registration: `akasha-daemon/src/main.rs:4664`.

<a id="post-v1-memory-vault-update" />

## POST `/v1/memory/vault/update` [#post-v1memoryvaultupdate]

Vault update

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-5]

**Json** — `VaultUpdateReq`

| Field   | Rust type    | Required on input | Notes |
| ------- | ------------ | ----------------- | ----- |
| `entry` | `VaultEntry` | Yes               |       |

```rust
struct VaultUpdateReq {
    entry: VaultEntry,
}
```

### Response [#response-5]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"ok": true})
```

### Errors and validation [#errors-and-validation-5]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn vault_update(
        State(state): State<AppState>,
        Extension(authority): Extension<RequestAuthority>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<VaultUpdateReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let ctx = vault_user_context(&authority, "vault:write");
        db.vault_update(&req.entry, &ctx)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:7630`. Registration: `akasha-daemon/src/main.rs:4665`.

<a id="post-v1-memory-vault-access-log" />

## POST `/v1/memory/vault/access-log` [#post-v1memoryvaultaccess-log]

Vault access log

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-6]

**Implementation limit:** Placeholder implementation: returns an empty JSON array; backend data retrieval is not implemented here.

**Json** — `VaultAccessLogReq`

| Field      | Rust type        | Required on input         | Notes |
| ---------- | ---------------- | ------------------------- | ----- |
| `entry_id` | `Option<String>` | No; optional or defaulted |       |

```rust
struct VaultAccessLogReq {
    #[allow(dead_code)]
    entry_id: Option<String>,
}
```

### Response [#response-6]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!([])
```

### Errors and validation [#errors-and-validation-6]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn vault_access_log(
        State(state): State<AppState>,
        Json(_req): Json<VaultAccessLogReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        // Stub: returns empty array until vault operations emit audit events
        Ok(Json(serde_json::json!([])))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:10526`. Registration: `akasha-daemon/src/main.rs:4701`.