Skip to main content

qualia_core_db/inference/inference_agent/governed/
candidate.rs

1use 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/// Actual proposal data supplied by the numerical/caller adapter. This is not a
10/// semantic classifier: `observation` must be the adapter's actual candidate
11/// observation, not a fabricated "safe" fact. Its source is part of qualification.
12#[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/// Admission values supplied by the authenticated host, then frozen for the
83/// request. Model identity must identify actual immutable model bytes/revision.
84#[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}