Skip to main content

qualia_core_db/inference/qwen/
retained.rs

1//! Cold immutable Qwen input closure for the authenticated native product route.
2use std::sync::{atomic::{AtomicU64, Ordering}, Arc};
3pub use etalon_model_io::lease::BundleLimits;
4use etalon_model_io::lease::{bundle_digest, ModelLease, ModelPart, ModelPartRole};
5use crate::gguf_sharder::{GgufTensorIndex, GgufTensorInfo, GgufTokenizer};
6use super::{validate_qwen4exp_graph,
7    PleNvmeReader, Qwen4ExpNativeRuntime, Qwen4ExpTrunkResidency, TrunkNvmeReader};
8
9static GENERATION: AtomicU64 = AtomicU64::new(1);
10
11/// Independently verified leases are selected by the host, never derived from
12/// descriptor path claims. The tokenizer is parsed from the retained trunk KV.
13pub struct QwenRetainedSources {
14    pub package: Arc<ModelLease>,
15    pub trunk: Arc<ModelLease>,
16    pub ple: Arc<ModelLease>,
17}
18
19/// This owner exposes no mutable runtime, tokenizer or source replacement API.
20/// Dropping it disposes every stateful reader; rejected decode owns its session.
21pub struct QwenRetainedRuntime {
22    pub(crate) runtime: Qwen4ExpNativeRuntime,
23    pub(crate) tokenizer: Arc<GgufTokenizer>,
24    _sources: QwenRetainedSources,
25    digest: [u8; 32],
26    generation: u64,
27}
28impl QwenRetainedRuntime {
29    pub fn activate(
30        sources: QwenRetainedSources,
31        limits: BundleLimits,
32        metadata_bytes: usize,
33        scratch_bytes: usize,
34        residency: Qwen4ExpTrunkResidency,
35    ) -> Result<Self, String> {
36        // No tile source is active in this scalar driver. Its source set is
37        // closed: external tile/tokenizer overrides cannot enter this owner.
38        let parts = [
39            ModelPart { role: ModelPartRole::BaseModel, format_version: 1, ordinal: 0, lease: &sources.trunk },
40            ModelPart { role: ModelPartRole::Shard, format_version: 1, ordinal: 0, lease: &sources.ple },
41            ModelPart { role: ModelPartRole::Configuration, format_version: 1, ordinal: 0, lease: &sources.package },
42        ];
43        let digest = bundle_digest(&parts, limits).map_err(|e| format!("Qwen bundle: {e:?}"))?;
44        if sources.package.bytes().len() > metadata_bytes || metadata_bytes < 24 {
45            return Err("Qwen descriptor metadata budget exceeded".into());
46        }
47        let descriptor = super::metadata::descriptor(sources.package.bytes(), metadata_bytes)?;
48        if descriptor.source.byte_len != sources.trunk.identity().byte_len
49            || descriptor.ple_storage.byte_len != sources.ple.identity().byte_len
50            || (!descriptor.source.sha256.is_empty()
51                && descriptor.source.sha256.as_slice() != sources.trunk.identity().content_sha256)
52        { return Err("Qwen retained source identity disagrees with descriptor".into()); }
53        let header = &sources.trunk.bytes()[..metadata_bytes.min(sources.trunk.bytes().len())];
54        super::metadata::gguf(header, metadata_bytes)?;
55        let index = GgufTensorIndex::from_gguf(header);
56        if index.tensor_data_start == 0 || index.tensor_data_start as usize > header.len() {
57            return Err("Qwen GGUF header exceeds selected metadata budget".into());
58        }
59        let mut contracts = [Default::default(); 64];
60        let graph = validate_qwen4exp_graph(&index, &mut contracts).map_err(|e| e.to_string())?;
61        let info = index.ple_ngram_embedding_info().ok_or("Qwen PLE tensor missing")?;
62        if graph.layers != descriptor.n_layer || index.ple_config != Some(descriptor.ple_config)
63            || info.dims[0] != descriptor.ple.row_width || info.dims[1] != descriptor.ple.rows
64            || info.ggml_type != descriptor.ple.ggml_type
65        { return Err("Qwen retained graph disagrees with descriptor".into()); }
66        let ple_info = GgufTensorInfo { byte_offset: 0, ..*info };
67        let ple = PleNvmeReader::from_lease(sources.ple.clone(), ple_info).map_err(|e| format!("Qwen PLE: {e:?}"))?;
68        if ple.raw_row_bytes() as u64 != descriptor.ple.row_bytes {
69            return Err("Qwen PLE row width disagrees with descriptor".into());
70        }
71        let trunk = TrunkNvmeReader::from_lease(sources.trunk.clone(), index.tensor_data_start,
72            residency == Qwen4ExpTrunkResidency::Mapped, scratch_bytes).map_err(|e| e.to_string())?;
73        let tokenizer = Arc::new(GgufTokenizer::from_gguf(&header[..index.tensor_data_start as usize]));
74        let generation = GENERATION.try_update(Ordering::AcqRel, Ordering::Acquire,
75            |v| v.checked_add(1)).map_err(|_| "Qwen generation exhausted")?;
76        Ok(Self { runtime: Qwen4ExpNativeRuntime { descriptor, index, ple, trunk },
77            tokenizer, _sources: sources, digest, generation })
78    }
79    pub fn model_digest(&self) -> [u8; 32] { self.digest }
80    pub fn generation(&self) -> u64 { self.generation }
81    pub fn tokenizer_owner(&self) -> Arc<GgufTokenizer> { self.tokenizer.clone() }
82    pub fn tokenizer(&self) -> &GgufTokenizer { &self.tokenizer }
83}