qualia_core_db/inference/inference_agent/governed/
candidate.rs1use super::PolicyError;
2use crate::NQuin;
3use etalon_inference_contract::CandidateOutput;
4use sha2::{Digest, Sha256};
5
6#[allow(dead_code)]
7pub const TOKEN_EVIDENCE_BYTES: usize = 68;
8
9#[derive(Clone, Copy, Debug)]
13pub struct TokenProposal {
14 pub position: u64,
15 pub token: u32,
16 pub logit: f32,
17 pub observation: NQuin,
18}
19#[allow(dead_code)]
20impl TokenProposal {
21 pub(crate) fn encode(self) -> Result<[u8; TOKEN_EVIDENCE_BYTES], PolicyError> {
22 let q = self.observation;
23 if !self.logit.is_finite() || q.parity != q.subject ^ q.predicate ^ q.object ^ q.context {
24 return Err(PolicyError::InvalidCandidate);
25 }
26 let mut out = [0; TOKEN_EVIDENCE_BYTES];
27 out[..4].copy_from_slice(&1u32.to_le_bytes());
28 out[4..12].copy_from_slice(&self.position.to_le_bytes());
29 out[12..16].copy_from_slice(&self.token.to_le_bytes());
30 out[16..20].copy_from_slice(&self.logit.to_bits().to_le_bytes());
31 for (chunk, value) in out[20..].chunks_exact_mut(8).zip([
32 q.subject,
33 q.predicate,
34 q.object,
35 q.context,
36 q.metadata,
37 q.parity,
38 ]) {
39 chunk.copy_from_slice(&value.to_le_bytes());
40 }
41 Ok(out)
42 }
43 pub(crate) fn decode(bytes: &[u8]) -> Result<Self, PolicyError> {
44 if bytes.len() != TOKEN_EVIDENCE_BYTES || bytes[..4] != 1u32.to_le_bytes() {
45 return Err(PolicyError::InvalidCandidate);
46 }
47 let u64_at =
48 |i| u64::from_le_bytes(bytes[i..i + 8].try_into().expect("checked evidence length"));
49 let proposal = Self {
50 position: u64_at(4),
51 token: u32::from_le_bytes(bytes[12..16].try_into().unwrap()),
52 logit: f32::from_bits(u32::from_le_bytes(bytes[16..20].try_into().unwrap())),
53 observation: NQuin {
54 subject: u64_at(20),
55 predicate: u64_at(28),
56 object: u64_at(36),
57 context: u64_at(44),
58 metadata: u64_at(52),
59 parity: u64_at(60),
60 },
61 };
62 proposal.encode()?;
63 Ok(proposal)
64 }
65 pub(crate) fn output(self) -> Result<CandidateOutput, PolicyError> {
66 let bytes = self.encode()?;
67 let mut h = Sha256::new();
68 h.update(b"qualia:token-output:v1\0");
69 h.update(&bytes[..20]);
70 let output_digest = h.finalize().into();
71 let mut h = Sha256::new();
72 h.update(b"qualia:token-observation:v1\0");
73 h.update(bytes);
74 Ok(CandidateOutput {
75 output_digest,
76 observation_digest: h.finalize().into(),
77 token_count: 1,
78 })
79 }
80}
81
82#[derive(Clone, Copy, Debug)]
85#[allow(dead_code)]
86pub struct InferenceAdmission {
87 pub request_digest: [u8; 32],
88 pub model_digest: [u8; 32],
89 pub model_generation: u64,
90 pub device_id: u64,
91 pub device_generation: u64,
92 pub graph_scope: u64,
93 pub first_position: u64,
94 pub instrumentation: etalon_inference_contract::Instrumentation,
95}