qualia_cli/handlers/inference_policy/
qwen.rs1use 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 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}