Skip to main content

qualia_cli/handlers/inference_policy/
qwen.rs

1//! Governed Qwen CLI route; login uses the existing configured native profile.
2use super::{eval::EvalLogin, io, profile};
3use qualia_client_core::api::inference_policy as api;
4use qualia_core_db::{key_vault::KeyVault,
5    llm_agent::native_request::{NativeInputBudget, NativePreparationSpec},
6    inference::{qwen::{retained::{BundleLimits, QwenRetainedRuntime, QwenRetainedSources},
7        Qwen4ExpTrunkResidency}, speculative_decode::DominoPreparationBudget}};
8use serde::Deserialize;
9use std::path::{Path, PathBuf};
10
11#[derive(Deserialize)]
12#[serde(deny_unknown_fields)]
13struct Source { path: PathBuf, expected_sha256: [u8; 32] }
14#[derive(Deserialize)]
15#[serde(deny_unknown_fields)]
16struct Authority {
17    profile: PathBuf,
18    subject: String,
19    identifier: qualia_client_core::inference_policy::SelectedInferenceIdentifier,
20    signer_label: String,
21    lifetime_seconds: u64,
22    package: Source,
23    trunk: Source,
24    ple: Source,
25    source_byte_budget: u64,
26    mapped_byte_budget: u64,
27    total_byte_budget: u64,
28    metadata_bytes: usize,
29    reader_scratch_bytes: usize,
30    state_bytes: u64,
31    decode_scratch_bytes: u64,
32    tokenizer_scratch_bytes: usize,
33    evidence_bytes: usize,
34    output_tokens: usize,
35    graph: u64,
36}
37
38pub(crate) fn run_qwen_governed(
39    authority: &Path, package_path: &Path, prompt: Option<&str>, ids: &[u32],
40    max_tokens: usize, context: usize, chat: bool, mapped: bool,
41) -> Result<(), String> {
42    let input: Authority = io::json(authority, 64 * 1024)?;
43    let root = profile::bind_child(&input.profile, false)?;
44    if std::fs::canonicalize(package_path).map_err(|e| e.to_string())?
45        != std::fs::canonicalize(&input.package.path).map_err(|e| e.to_string())?
46    { return Err("Qwen command package differs from the authority's selected package".into()); }
47    if max_tokens > input.output_tokens || input.evidence_bytes > 1024 * 1024
48        || input.evidence_bytes < 65_536
49    { return Err("Qwen output/evidence budget refused".into()); }
50    let output_bytes = max_tokens.checked_mul(std::mem::size_of::<u32>())
51        .filter(|bytes| *bytes <= isize::MAX as usize).ok_or("Qwen output byte size overflow")?;
52    let selected_output_bytes = input.output_tokens.checked_mul(std::mem::size_of::<u32>())
53        .filter(|bytes| *bytes <= isize::MAX as usize).ok_or("Qwen selected output budget overflow")?;
54    if output_bytes > selected_output_bytes || context == 0
55        || max_tokens.saturating_sub(1) > context {
56        return Err("Qwen selected output/context capacity refused".into());
57    }
58    let vault = KeyVault::open_native_secure(root.to_str().ok_or("Profile is not UTF-8")?, false)?;
59    qualia_client_core::state::init_inference_host_state(vault)?;
60    let login = EvalLogin(api::login_inference_actor(input.subject, input.identifier,
61        input.signer_label, input.lifetime_seconds)?);
62    let cancelled = std::sync::atomic::AtomicBool::new(false);
63    let mut remaining = [input.source_byte_budget, input.mapped_byte_budget, input.total_byte_budget];
64    let mut open = |source: Source| -> Result<_, String> {
65        let lease = NativePreparationSpec::open_model_lease(&source.path, source.expected_sha256,
66            remaining, &cancelled)?;
67        let len = lease.identity().byte_len;
68        let total = len.checked_mul(2).ok_or("Qwen lease accounting overflow")?;
69        for (budget, charge) in remaining.iter_mut().zip([len, len, total]) {
70            *budget = budget.checked_sub(charge).ok_or("Qwen aggregate lease budget exhausted")?;
71        }
72        Ok(lease)
73    };
74    let package = open(input.package)?;
75    let trunk = open(input.trunk)?;
76    let ple = open(input.ple)?;
77    let preparation = NativePreparationSpec::Leased {
78        primary: trunk.clone(), shards: vec![trunk.clone(), ple.clone(), package.clone()],
79        metadata_budget: input.metadata_bytes,
80        inputs: NativeInputBudget { retained_bytes: input.metadata_bytes,
81            tokenizer_scratch_bytes: input.tokenizer_scratch_bytes,
82            // This scalar route does not activate the generic grammar decoder.
83            domino: DominoPreparationBudget { owned_bytes: 0, text_bytes: 0, stack_depth: 0 } },
84    };
85    let product = api::get_native_inference_session(&login.0, preparation)?;
86    let runtime = QwenRetainedRuntime::activate(QwenRetainedSources { package, trunk, ple },
87        BundleLimits { max_parts: 3, max_source_bytes: input.source_byte_budget },
88        input.metadata_bytes, input.reader_scratch_bytes,
89        if mapped { Qwen4ExpTrunkResidency::Mapped } else { Qwen4ExpTrunkResidency::Streamed })?;
90    let tokenizer = runtime.tokenizer_owner();
91    if ids.len() > input.metadata_bytes / 4 || prompt.is_some_and(|text| text.len() > input.metadata_bytes) {
92        return Err("Qwen prompt exceeds selected input budget".into());
93    }
94    let tokens = if !ids.is_empty() { ids.to_vec() }
95        else if let Some(text) = prompt {
96            if chat { tokenizer.encode_chat_prompt(text) } else { tokenizer.encode_prompt(text) }
97        } else { return Err("decode-qwen4exp needs --prompt or --token-ids".into()); };
98    if tokens.is_empty() || tokens.len().checked_add(max_tokens.saturating_sub(1))
99        .filter(|required| *required <= context).is_none() {
100        return Err("Qwen prompt plus generated state exceeds selected context capacity".into());
101    }
102    let mut output = Vec::new();
103    output.try_reserve_exact(max_tokens).map_err(|_| "Qwen output allocation refused")?;
104    output.resize(max_tokens, 0u32);
105    let mut evidence = Vec::new();
106    evidence.try_reserve_exact(input.evidence_bytes).map_err(|_| "Qwen evidence allocation refused")?;
107    evidence.resize(input.evidence_bytes, 0u8);
108    use qualia_core_db::llm_agent::governed::evidence::{EvidenceLimits, EvidenceStorage};
109    let mut storage = EvidenceStorage::new(&mut evidence, EvidenceLimits {
110        storage_bytes: input.evidence_bytes.checked_add(std::mem::size_of::<EvidenceStorage<'_>>())
111            .ok_or("Qwen evidence budget overflow")?,
112        max_payload_bytes: 65_536, max_artifact_events: 1,
113    }).map_err(|e| format!("Qwen evidence storage: {e:?}"))?;
114    let count = product.decode_qwen_into(runtime, &tokens, input.graph, max_tokens, context,
115        input.state_bytes, input.decode_scratch_bytes, input.tokenizer_scratch_bytes,
116        &mut output, &mut storage).map_err(|e| format!("Governed Qwen decode refused: {e:?}"))?;
117    println!("execution_mode=Governed generated_tokens={count}");
118    println!("{}", tokenizer.decode(&output[..count]));
119    Ok(())
120}