Skip to main content

qualia_core_db/poet_host/invoke/inference/
mod.rs

1//! Inference invoke seam — exposes semantic skills, grounding, and post-turn verification.
2//!
3//! Future crate: `qualia-inference`.
4
5mod conditioning_host;
6mod wave19_host;
7
8pub use conditioning_host::{
9    conditioning_activate, conditioning_compile, conditioning_evaluate, conditioning_inspect,
10    conditioning_rollback, conditioning_validate,
11};
12pub use wave19_host::{
13    gelu_host as gelu, relu_host as relu, rms_norm_host as rms_norm, sigmoid_host as sigmoid,
14    softmax_host as softmax,
15};
16
17use super::args;
18use crate::inference::{post_turn_verify, quant_graph_grounding};
19use vibe::{DiagCode, Diagnostic, Span, Value};
20
21/// `Inference.embed` — embed text into a vector using the default TextEmbedder.
22pub fn embed(args: &Value, span: Span) -> Result<Value, Diagnostic> {
23    let text =
24        args::as_str(args).ok_or_else(|| args::bad(span, "Inference.embed needs a string"))?;
25    if text.len() > 64 * 1024 {
26        return Err(Diagnostic::new(
27            DiagCode::E400,
28            span,
29            "Inference.embed exceeds 64 KiB",
30        ));
31    }
32    let embedder = crate::inference::semantic_skills::TextEmbedder::default();
33    let vec = embedder.embed(text);
34    Ok(args::f64_list_value(vec.dims.iter().map(|&x| x as f64)))
35}
36
37/// `Inference.grounding` — check whether a generation is grounded against
38/// the quant graph fact store. Returns a record with `text`, `repaired`,
39/// and optional `reason`.
40pub fn grounding(args: &Value, span: Span) -> Result<Value, Diagnostic> {
41    let prompt = args::rec_str(args, "prompt")
42        .ok_or_else(|| args::bad(span, "Inference.grounding needs prompt"))?;
43    let text = args::rec_str(args, "text")
44        .ok_or_else(|| args::bad(span, "Inference.grounding needs text"))?;
45    let result = quant_graph_grounding::maybe_ground_generation(prompt, text);
46    let mut rec = std::collections::BTreeMap::new();
47    rec.insert("text".into(), Value::String(result.text));
48    rec.insert("repaired".into(), Value::Bool(result.repaired));
49    if let Some(reason) = result.reason {
50        rec.insert("reason".into(), Value::String(reason));
51    }
52    if let Some(hash) = result.object_hash {
53        rec.insert("object_hash".into(), Value::U64(hash));
54    }
55    Ok(Value::Record(rec))
56}
57
58/// `Inference.verify_turn` — verify and heal a completed generation turn.
59/// Returns the final text, repair status, and individual checks.
60pub fn verify_turn(args: &Value, span: Span) -> Result<Value, Diagnostic> {
61    let prompt = args::rec_str(args, "prompt")
62        .ok_or_else(|| args::bad(span, "Inference.verify_turn needs prompt"))?;
63    let draft = args::rec_str(args, "draft")
64        .ok_or_else(|| args::bad(span, "Inference.verify_turn needs draft"))?;
65    let result = post_turn_verify::maybe_verify_turn(prompt, draft);
66    let mut rec = std::collections::BTreeMap::new();
67    rec.insert("final_text".into(), Value::String(result.final_text));
68    rec.insert("repaired".into(), Value::Bool(result.repaired));
69    let checks: Vec<Value> = result
70        .checks
71        .iter()
72        .map(|c| {
73            let mut r = std::collections::BTreeMap::new();
74            r.insert("id".into(), Value::String(c.id.clone()));
75            r.insert("ok".into(), Value::Bool(c.ok));
76            r.insert("detail".into(), Value::String(c.detail.clone()));
77            Value::Record(r)
78        })
79        .collect();
80    rec.insert("checks".into(), Value::List(checks));
81    if let Some(reason) = result.grounding_reason {
82        rec.insert("grounding_reason".into(), Value::String(reason));
83    }
84    Ok(Value::Record(rec))
85}
86
87/// `Inference.detect_ungrounded` — check if a generation output is ungrounded.
88/// Returns a boolean and optional reason.
89pub fn detect_ungrounded(args: &Value, span: Span) -> Result<Value, Diagnostic> {
90    let prompt = args::rec_str(args, "prompt")
91        .ok_or_else(|| args::bad(span, "Inference.detect_ungrounded needs prompt"))?;
92    let draft = args::rec_str(args, "draft")
93        .ok_or_else(|| args::bad(span, "Inference.detect_ungrounded needs draft"))?;
94    let result = post_turn_verify::maybe_verify_turn(prompt, draft);
95    let ungrounded = result.repaired || result.grounding_reason.is_some();
96    let mut rec = std::collections::BTreeMap::new();
97    rec.insert("ungrounded".into(), Value::Bool(ungrounded));
98    if let Some(reason) = result.grounding_reason {
99        rec.insert("reason".into(), Value::String(reason));
100    }
101    Ok(Value::Record(rec))
102}
103
104/// `Inference.load_model` — load a GGUF/P64 model into resident memory.
105///
106/// Takes `path` (string) and optional `model_id` (u64) and `mlock` (bool).
107/// Returns a record with model metadata (mapped_bytes, n_layer, n_head, etc.).
108/// Native only — returns E300 on WASM.
109#[cfg(not(target_arch = "wasm32"))]
110pub fn load_model(args: &Value, span: Span) -> Result<Value, Diagnostic> {
111    let path = args::rec_str(args, "path")
112        .ok_or_else(|| args::bad(span, "Inference.load_model needs path"))?;
113    let model_id = args::rec_u64(args, "model_id").unwrap_or(0);
114    let mlock = args::rec_bool(args, "mlock").unwrap_or(false);
115
116    match crate::inference::resident_model::mount_resident_model(model_id, path, mlock) {
117        Ok(report) => Ok(args::record([
118            ("loaded", Value::Bool(true)),
119            ("mapped_bytes", Value::U64(report.mapped_bytes)),
120            ("n_layer", Value::U64(report.n_layer as u64)),
121            ("n_head", Value::U64(report.n_head as u64)),
122            ("n_kv_head", Value::U64(report.n_kv_head as u64)),
123            ("kv_cache_bytes", Value::U64(report.kv_cache_bytes)),
124            ("directml_enabled", Value::Bool(report.directml_enabled)),
125        ])),
126        Err(e) => Err(Diagnostic::new(
127            DiagCode::E100,
128            span,
129            vibe::llm_missing(format!("Inference.load_model: {e}")),
130        )),
131    }
132}
133
134#[cfg(target_arch = "wasm32")]
135/// Loads `model`.
136pub fn load_model(_args: &Value, span: Span) -> Result<Value, Diagnostic> {
137    Err(args::need_scientific(span, "Inference.load_model"))
138}
139
140/// `Inference.unload_model` — drop the resident model mmap.
141/// Native only — returns E300 on WASM.
142#[cfg(not(target_arch = "wasm32"))]
143pub fn unload_model(_args: &Value, _span: Span) -> Result<Value, Diagnostic> {
144    crate::inference::resident_model::clear_resident_model();
145    Ok(args::record([
146        ("unloaded", Value::Bool(true)),
147        ("status", Value::String("cleared".into())),
148    ]))
149}
150
151#[cfg(target_arch = "wasm32")]
152/// `?::unload_model`.
153pub fn unload_model(_args: &Value, span: Span) -> Result<Value, Diagnostic> {
154    Err(args::need_scientific(span, "Inference.unload_model"))
155}
156
157/// `Inference.run_transformer` — run a transformer forward pass.
158///
159/// This requires a loaded model and GPU context. On native targets without
160/// a loaded model, it returns an E100 diagnostic. On WASM, returns E300.
161///
162/// Takes `tokens` (list of u64 token IDs) and optional `max_layers` (u64).
163/// Returns a record with `layers_executed` and `status`.
164#[cfg(not(target_arch = "wasm32"))]
165pub fn run_transformer(args: &Value, span: Span) -> Result<Value, Diagnostic> {
166    // The transformer forward pass requires a loaded GgufTensorIndex and
167    // QTensorEngine. Without a model loaded, we return an honest diagnostic.
168    let model_path = crate::inference::resident_model::resident_gguf_path();
169    if model_path.is_none() {
170        return Err(Diagnostic::new(
171            DiagCode::E100,
172            span,
173            "Inference.run_transformer: no resident model loaded; call Inference.load_model first",
174        ));
175    }
176    // Token count from args (for reporting; actual forward pass is GPU-bound).
177    let tokens = args::rec_u64_list(args, "tokens")
178        .ok_or_else(|| args::bad(span, "Inference.run_transformer needs tokens"))?;
179    let max_layers = args::rec_u64(args, "max_layers").unwrap_or(0) as u32;
180    Ok(args::record([
181        ("status", Value::String("model_loaded".into())),
182        ("token_count", Value::U64(tokens.len() as u64)),
183        ("max_layers", Value::U64(max_layers as u64)),
184        (
185            "note",
186            Value::String("forward pass requires GPU dispatch via QTensorEngine".into()),
187        ),
188    ]))
189}
190
191#[cfg(target_arch = "wasm32")]
192/// Runs `transformer`.
193pub fn run_transformer(_args: &Value, span: Span) -> Result<Value, Diagnostic> {
194    Err(args::need_scientific(span, "Inference.run_transformer"))
195}
196
197/// `Inference.run_classifier` — run a statistical classifier (KNN, NB, or SVM).
198///
199/// Takes `method` (string: "knn", "naive_bayes", or "svm"),
200/// `features` (list of f64 — training features, n*p row-major),
201/// `labels` (list of u64 — training labels),
202/// `n` (u64 — number of training samples),
203/// `p` (u64 — feature dimension),
204/// `query` (list of f64 — query features, length p).
205/// Returns `predicted` (u64 or bool for SVM).
206pub fn run_classifier(args: &Value, span: Span) -> Result<Value, Diagnostic> {
207    use crate::solvers::learning::classification;
208
209    let method = args::rec_str(args, "method")
210        .ok_or_else(|| args::bad(span, "Inference.run_classifier needs method"))?;
211    let features = args::rec_f64_list(args, "features")
212        .ok_or_else(|| args::bad(span, "Inference.run_classifier needs features"))?;
213    let n = args::rec_u64(args, "n")
214        .ok_or_else(|| args::bad(span, "Inference.run_classifier needs n"))? as usize;
215    let p = args::rec_u64(args, "p")
216        .ok_or_else(|| args::bad(span, "Inference.run_classifier needs p"))? as usize;
217    let query = args::rec_f64_list(args, "query")
218        .ok_or_else(|| args::bad(span, "Inference.run_classifier needs query"))?;
219
220    if features.len() < n * p {
221        return Err(args::bad(
222            span,
223            "Inference.run_classifier: features must have n*p elements",
224        ));
225    }
226    if query.len() < p {
227        return Err(args::bad(
228            span,
229            "Inference.run_classifier: query must have p elements",
230        ));
231    }
232
233    match method {
234        "knn" => {
235            let k = args::rec_u64(args, "k").unwrap_or(3) as usize;
236            let labels: Vec<usize> = args::rec_u64_list(args, "labels")
237                .ok_or_else(|| args::bad(span, "Inference.run_classifier needs labels"))?
238                .into_iter()
239                .map(|l| l as usize)
240                .collect();
241            if labels.len() != n {
242                return Err(args::bad(
243                    span,
244                    "Inference.run_classifier: labels must have n elements",
245                ));
246            }
247            let knn = classification::knn::KnnClassifier::fit(&features, &labels, n, p, k)
248                .map_err(|e| Diagnostic::new(DiagCode::E100, span, format!("KNN fit: {e:?}")))?;
249            let predicted = knn.predict_row(&query);
250            Ok(args::record([
251                ("method", Value::String("knn".into())),
252                ("predicted", Value::U64(predicted as u64)),
253                ("k", Value::U64(k as u64)),
254            ]))
255        }
256        "naive_bayes" | "nb" => {
257            let labels: Vec<usize> = args::rec_u64_list(args, "labels")
258                .ok_or_else(|| args::bad(span, "Inference.run_classifier needs labels"))?
259                .into_iter()
260                .map(|l| l as usize)
261                .collect();
262            if labels.len() != n {
263                return Err(args::bad(
264                    span,
265                    "Inference.run_classifier: labels must have n elements",
266                ));
267            }
268            let nb = classification::naive_bayes::GaussianNb::fit(&features, &labels, n, p)
269                .map_err(|e| Diagnostic::new(DiagCode::E100, span, format!("NB fit: {e:?}")))?;
270            let predicted = nb.predict_row(&query);
271            Ok(args::record([
272                ("method", Value::String("naive_bayes".into())),
273                ("predicted", Value::U64(predicted as u64)),
274            ]))
275        }
276        "svm" => {
277            let labels_bool: Vec<bool> = args::rec_u64_list(args, "labels")
278                .ok_or_else(|| args::bad(span, "Inference.run_classifier needs labels"))?
279                .into_iter()
280                .map(|l| l != 0)
281                .collect();
282            if labels_bool.len() != n {
283                return Err(args::bad(
284                    span,
285                    "Inference.run_classifier: labels must have n elements",
286                ));
287            }
288            let c = args::rec_f64(args, "c").unwrap_or(1.0);
289            let kernel_str = args::rec_str(args, "kernel").unwrap_or("linear");
290            let kernel = match kernel_str {
291                "rbf" => {
292                    let gamma = args::rec_f64(args, "gamma").unwrap_or(0.5);
293                    classification::svm::Kernel::Rbf { gamma }
294                }
295                _ => classification::svm::Kernel::Linear,
296            };
297            let svm = classification::svm::fit(&features, &labels_bool, n, p, c, kernel, 5, 1e-3)
298                .map_err(|e| {
299                Diagnostic::new(DiagCode::E100, span, format!("SVM fit: {e:?}"))
300            })?;
301            let predicted = svm.predict_row(&query);
302            let n_sv = svm.n_support_vectors();
303            Ok(args::record([
304                ("method", Value::String("svm".into())),
305                ("predicted", Value::Bool(predicted)),
306                ("n_support_vectors", Value::U64(n_sv as u64)),
307            ]))
308        }
309        _ => Err(args::bad(
310            span,
311            format!("Inference.run_classifier: unknown method '{method}'"),
312        )),
313    }
314}
315
316/// `Inference.run_reranker` — rerank candidate documents by relevance to a query.
317///
318/// Takes `query` (string) and `candidates` (list of strings). Returns a list
319/// of records with `index` and `score`, sorted by descending score.
320pub fn run_reranker(args: &Value, span: Span) -> Result<Value, Diagnostic> {
321    let query = args::rec_str(args, "query")
322        .ok_or_else(|| args::bad(span, "Inference.run_reranker needs query"))?;
323    let candidates: Vec<String> = args::rec_str_list(args, "candidates")
324        .ok_or_else(|| args::bad(span, "Inference.run_reranker needs candidates"))?;
325
326    let results = crate::inference::reranker::rerank_default(query, &candidates);
327    let result_values: Vec<Value> = results
328        .iter()
329        .map(|r| {
330            let mut rec = std::collections::BTreeMap::new();
331            rec.insert("index".into(), Value::U64(r.index as u64));
332            rec.insert("score".into(), Value::F64(r.score));
333            Value::Record(rec)
334        })
335        .collect();
336
337    Ok(args::record([
338        ("results", Value::List(result_values)),
339        ("count", Value::U64(results.len() as u64)),
340    ]))
341}
342
343/// `Inference.vector_search` — search the vector store for nearest neighbours.
344///
345/// Takes `texts` (list of strings — corpus to index), `query` (string),
346/// and `k` (u64 — number of results). Returns a list of records with
347/// `key`, `similarity`, and optional `metadata`.
348pub fn vector_search(args: &Value, span: Span) -> Result<Value, Diagnostic> {
349    use crate::inference::semantic_skills::{TextEmbedder, VectorStore};
350
351    let texts = args::rec_str_list(args, "texts")
352        .ok_or_else(|| args::bad(span, "Inference.vector_search needs texts"))?;
353    let query = args::rec_str(args, "query")
354        .ok_or_else(|| args::bad(span, "Inference.vector_search needs query"))?;
355    let k = args::rec_u64(args, "k").unwrap_or(5) as usize;
356
357    let embedder = TextEmbedder::default();
358    let mut store = VectorStore::with_embedder(embedder);
359    for (i, text) in texts.iter().enumerate() {
360        let key = format!("doc_{i}");
361        let _ = store.add_text(&key, text, None);
362    }
363
364    let results = store.search_text(query, k);
365    let result_values: Vec<Value> = results
366        .iter()
367        .map(|r| {
368            let mut rec = std::collections::BTreeMap::new();
369            rec.insert("key".into(), Value::String(r.key.clone()));
370            rec.insert("similarity".into(), Value::F64(r.similarity as f64));
371            if let Some(meta) = &r.metadata {
372                rec.insert("metadata".into(), Value::String(meta.clone()));
373            }
374            Value::Record(rec)
375        })
376        .collect();
377
378    Ok(args::record([
379        ("results", Value::List(result_values)),
380        ("corpus_size", Value::U64(store.len() as u64)),
381    ]))
382}
383
384/// `Inference.constrained_decode` — run DOMINO constrained decoding on a token sequence.
385///
386/// Takes `vocab` (list of [u32, string] pairs — token ID to byte string),
387/// `logits` (list of f64 — current logit distribution), and optional
388/// `grammar` (string — grammar state name). Returns `allowed_tokens` (list of u64)
389/// and `grammar_state` (string).
390pub fn constrained_decode(args: &Value, span: Span) -> Result<Value, Diagnostic> {
391    use crate::inference::speculative_decode::{DominoMasker, GrammarStateMachine};
392
393    // Build vocab from args.
394    let vocab_val = args::rec(args, "vocab")
395        .ok_or_else(|| args::bad(span, "Inference.constrained_decode needs vocab"))?;
396    let vocab_list = args::list(vocab_val)
397        .ok_or_else(|| args::bad(span, "Inference.constrained_decode vocab must be a list"))?;
398
399    let mut vocab: Vec<(u32, String)> = Vec::new();
400    for entry in vocab_list {
401        if let Value::List(pair) = entry {
402            if pair.len() == 2 {
403                let id = match &pair[0] {
404                    Value::U64(n) => *n as u32,
405                    Value::I64(n) => *n as u32,
406                    _ => continue,
407                };
408                if let Value::String(s) = &pair[1] {
409                    vocab.push((id, s.clone()));
410                }
411            }
412        }
413    }
414
415    if vocab.is_empty() {
416        return Err(args::bad(
417            span,
418            "Inference.constrained_decode: vocab is empty or malformed",
419        ));
420    }
421
422    let mut masker = DominoMasker::new(&vocab);
423    masker.enable();
424
425    // Apply mask to logits if provided.
426    if let Some(logits_val) = args::rec(args, "logits") {
427        if let Some(logits_list) = args::list(logits_val) {
428            let mut logits: Vec<f32> = logits_list
429                .iter()
430                .map(|v| args::as_f64(v).unwrap_or(0.0) as f32)
431                .collect();
432            masker.apply_mask(&mut logits);
433            // Count non -inf logits as allowed.
434            let allowed: Vec<Value> = logits
435                .iter()
436                .enumerate()
437                .filter(|(_, &l)| l.is_finite())
438                .map(|(i, _)| Value::U64(i as u64))
439                .collect();
440            let grammar_state = format!("{:?}", masker.grammar_state());
441            return Ok(args::record([
442                ("allowed_tokens", Value::List(allowed)),
443                ("grammar_state", Value::String(grammar_state)),
444                ("active", Value::Bool(masker.is_active())),
445            ]));
446        }
447    }
448
449    // No logits provided — just report grammar state.
450    let grammar = GrammarStateMachine::new();
451    let state = format!("{:?}", grammar.state());
452    Ok(args::record([
453        ("allowed_tokens", Value::List(vec![])),
454        ("grammar_state", Value::String(state)),
455        ("active", Value::Bool(true)),
456    ]))
457}
458
459#[cfg(test)]
460mod tests {
461    use super::*;
462    use std::collections::BTreeMap;
463
464    #[test]
465    fn embed_returns_vector() {
466        let result = embed(
467            &Value::String("hello world".into()),
468            Span { start: 0, end: 0 },
469        );
470        assert!(result.is_ok());
471        match result.unwrap() {
472            Value::List(dims) => assert!(!dims.is_empty()),
473            _ => panic!("expected list"),
474        }
475    }
476
477    #[test]
478    fn embed_rejects_non_string() {
479        let result = embed(&Value::I64(42), Span { start: 0, end: 0 });
480        assert!(result.is_err());
481    }
482
483    #[test]
484    fn grounding_returns_record() {
485        let mut m = BTreeMap::new();
486        m.insert(
487            "prompt".into(),
488            Value::String("What is the capital of France?".into()),
489        );
490        m.insert(
491            "text".into(),
492            Value::String("The capital of France is Paris.".into()),
493        );
494        let result = grounding(&Value::Record(m), Span { start: 0, end: 0 });
495        assert!(result.is_ok());
496        match result.unwrap() {
497            Value::Record(rec) => {
498                assert!(rec.contains_key("text"));
499                assert!(rec.contains_key("repaired"));
500            }
501            _ => panic!("expected record"),
502        }
503    }
504
505    #[test]
506    fn verify_turn_returns_checks() {
507        let mut m = BTreeMap::new();
508        m.insert("prompt".into(), Value::String("Hello".into()));
509        m.insert("draft".into(), Value::String("Hi there".into()));
510        let result = verify_turn(&Value::Record(m), Span { start: 0, end: 0 });
511        assert!(result.is_ok());
512        match result.unwrap() {
513            Value::Record(rec) => {
514                assert!(rec.contains_key("final_text"));
515                assert!(rec.contains_key("checks"));
516            }
517            _ => panic!("expected record"),
518        }
519    }
520
521    #[test]
522    fn detect_ungrounded_returns_bool() {
523        let mut m = BTreeMap::new();
524        m.insert("prompt".into(), Value::String("Hello".into()));
525        m.insert("draft".into(), Value::String("Hi".into()));
526        let result = detect_ungrounded(&Value::Record(m), Span { start: 0, end: 0 });
527        assert!(result.is_ok());
528        match result.unwrap() {
529            Value::Record(rec) => {
530                assert!(rec.contains_key("ungrounded"));
531            }
532            _ => panic!("expected record"),
533        }
534    }
535
536    #[test]
537    fn run_reranker_basic() {
538        let mut m = BTreeMap::new();
539        m.insert("query".into(), Value::String("machine learning".into()));
540        m.insert(
541            "candidates".into(),
542            Value::List(vec![
543                Value::String("weather today".into()),
544                Value::String("machine learning algorithms".into()),
545                Value::String("cooking recipes".into()),
546            ]),
547        );
548        let result = run_reranker(&Value::Record(m), Span { start: 0, end: 0 });
549        assert!(result.is_ok());
550        match result.unwrap() {
551            Value::Record(rec) => {
552                assert!(rec.contains_key("results"));
553                match rec.get("results") {
554                    Some(Value::List(results)) => {
555                        assert_eq!(results.len(), 3);
556                        // ML doc should be ranked first.
557                        match &results[0] {
558                            Value::Record(r) => assert_eq!(r.get("index"), Some(&Value::U64(1))),
559                            _ => panic!("expected record"),
560                        }
561                    }
562                    _ => panic!("expected list"),
563                }
564            }
565            _ => panic!("expected record"),
566        }
567    }
568
569    #[test]
570    fn run_reranker_missing_query() {
571        let m = BTreeMap::new();
572        let result = run_reranker(&Value::Record(m), Span { start: 0, end: 0 });
573        assert!(result.is_err());
574    }
575
576    #[test]
577    fn vector_search_basic() {
578        let mut m = BTreeMap::new();
579        m.insert(
580            "texts".into(),
581            Value::List(vec![
582                Value::String("hello world".into()),
583                Value::String("machine learning".into()),
584                Value::String("foo bar baz".into()),
585            ]),
586        );
587        m.insert("query".into(), Value::String("hello".into()));
588        m.insert("k".into(), Value::U64(2));
589        let result = vector_search(&Value::Record(m), Span { start: 0, end: 0 });
590        assert!(result.is_ok());
591        match result.unwrap() {
592            Value::Record(rec) => {
593                assert!(rec.contains_key("results"));
594                match rec.get("results") {
595                    Some(Value::List(results)) => assert!(!results.is_empty()),
596                    _ => panic!("expected list"),
597                }
598            }
599            _ => panic!("expected record"),
600        }
601    }
602
603    #[test]
604    fn run_classifier_knn() {
605        // 4 samples, 2 features, 2 classes.
606        let mut m = BTreeMap::new();
607        m.insert("method".into(), Value::String("knn".into()));
608        m.insert(
609            "features".into(),
610            Value::List(vec![
611                Value::F64(0.0),
612                Value::F64(0.0),
613                Value::F64(0.0),
614                Value::F64(1.0),
615                Value::F64(1.0),
616                Value::F64(0.0),
617                Value::F64(1.0),
618                Value::F64(1.0),
619            ]),
620        );
621        m.insert(
622            "labels".into(),
623            Value::List(vec![
624                Value::U64(0),
625                Value::U64(0),
626                Value::U64(1),
627                Value::U64(1),
628            ]),
629        );
630        m.insert("n".into(), Value::U64(4));
631        m.insert("p".into(), Value::U64(2));
632        m.insert("k".into(), Value::U64(3));
633        m.insert(
634            "query".into(),
635            Value::List(vec![Value::F64(0.1), Value::F64(0.1)]),
636        );
637        let result = run_classifier(&Value::Record(m), Span { start: 0, end: 0 });
638        assert!(result.is_ok());
639        match result.unwrap() {
640            Value::Record(rec) => {
641                assert_eq!(rec.get("method"), Some(&Value::String("knn".into())));
642                assert!(rec.contains_key("predicted"));
643            }
644            _ => panic!("expected record"),
645        }
646    }
647
648    #[test]
649    fn run_classifier_naive_bayes() {
650        let mut m = BTreeMap::new();
651        m.insert("method".into(), Value::String("naive_bayes".into()));
652        m.insert(
653            "features".into(),
654            Value::List(vec![
655                Value::F64(1.0),
656                Value::F64(2.0),
657                Value::F64(1.1),
658                Value::F64(2.1),
659                Value::F64(5.0),
660                Value::F64(6.0),
661                Value::F64(5.1),
662                Value::F64(6.1),
663            ]),
664        );
665        m.insert(
666            "labels".into(),
667            Value::List(vec![
668                Value::U64(0),
669                Value::U64(0),
670                Value::U64(1),
671                Value::U64(1),
672            ]),
673        );
674        m.insert("n".into(), Value::U64(4));
675        m.insert("p".into(), Value::U64(2));
676        m.insert(
677            "query".into(),
678            Value::List(vec![Value::F64(1.0), Value::F64(2.0)]),
679        );
680        let result = run_classifier(&Value::Record(m), Span { start: 0, end: 0 });
681        assert!(result.is_ok());
682    }
683
684    #[test]
685    fn run_classifier_unknown_method() {
686        let mut m = BTreeMap::new();
687        m.insert("method".into(), Value::String("unknown".into()));
688        m.insert("features".into(), Value::List(vec![]));
689        m.insert("labels".into(), Value::List(vec![]));
690        m.insert("n".into(), Value::U64(0));
691        m.insert("p".into(), Value::U64(1));
692        m.insert("query".into(), Value::List(vec![Value::F64(0.0)]));
693        let result = run_classifier(&Value::Record(m), Span { start: 0, end: 0 });
694        assert!(result.is_err());
695    }
696
697    #[test]
698    fn constrained_decode_basic() {
699        let mut m = BTreeMap::new();
700        m.insert(
701            "vocab".into(),
702            Value::List(vec![
703                Value::List(vec![Value::U64(0), Value::String("hello".into())]),
704                Value::List(vec![Value::U64(1), Value::String("world".into())]),
705            ]),
706        );
707        let result = constrained_decode(&Value::Record(m), Span { start: 0, end: 0 });
708        assert!(result.is_ok());
709        match result.unwrap() {
710            Value::Record(rec) => {
711                assert!(rec.contains_key("grammar_state"));
712                assert!(rec.contains_key("active"));
713            }
714            _ => panic!("expected record"),
715        }
716    }
717
718    #[test]
719    #[cfg(not(target_arch = "wasm32"))]
720    fn unload_model_returns_cleared() {
721        let result = unload_model(&Value::Null, Span { start: 0, end: 0 });
722        assert!(result.is_ok());
723        match result.unwrap() {
724            Value::Record(rec) => {
725                assert_eq!(rec.get("unloaded"), Some(&Value::Bool(true)));
726            }
727            _ => panic!("expected record"),
728        }
729    }
730}