sim-nest 0.1.25

The SIM constellation umbrella facade: one crate that re-exports the runtime kernel, codecs, number domains, and libraries behind features.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use sim_kernel::{
    Cx, Error, EvalFabric, EvalReply, EvalRequest, Expr, Object, ObjectCompat, Result, Symbol,
};
use sim_lib_intent::{Origin, intent};
use sim_lib_view_spatial::{XrMicChunkRef, glasses_mic_capability};
use sim_value::build;

/// Returns the placement symbol for the hardware-free cookbook ASR site.
pub fn modeled_asr_site_symbol() -> Symbol {
    Symbol::qualified("asr/site", "glasses-modeled")
}

pub(super) struct ModeledAsrSite;

impl Object for ModeledAsrSite {
    fn display(&self, _cx: &mut Cx) -> Result<String> {
        Ok("#<asr-site glasses-modeled>".to_owned())
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

impl ObjectCompat for ModeledAsrSite {
    fn as_expr(&self, _cx: &mut Cx) -> Result<Expr> {
        Ok(Expr::Symbol(modeled_asr_site_symbol()))
    }

    fn as_eval_fabric(&self) -> Option<&dyn EvalFabric> {
        Some(self)
    }
}

impl EvalFabric for ModeledAsrSite {
    fn realize(&self, cx: &mut Cx, request: EvalRequest) -> Result<EvalReply> {
        if !request
            .required_capabilities
            .contains(&glasses_mic_capability())
        {
            return Err(Error::CapabilityDenied {
                capability: glasses_mic_capability(),
            });
        }
        cx.require(&glasses_mic_capability())?;
        let chunk = XrMicChunkRef::from_expr(&request.expr)?;
        let response = intent(
            "invoke",
            Origin::agent(chunk.seq),
            vec![
                ("target", build::sym("focused")),
                (
                    "op",
                    Expr::Symbol(Symbol::qualified("glasses/voice", "modeled-asr")),
                ),
                (
                    "args",
                    build::list(vec![
                        Expr::Symbol(chunk.ref_id),
                        build::map(vec![("bytes", build::uint(chunk.byte_len))]),
                    ]),
                ),
            ],
        );
        Ok(EvalReply {
            value: cx.factory().expr(response)?,
            diagnostics: Vec::new(),
            trace: None,
        })
    }
}