use std::path::Path;
use logit_loom::Digest;
use logit_loom_llamacpp::{
LoraAdapter, Model, ModelOptions, Runtime, SessionOptions, Tokenization,
};
use logit_loom_models::{
ArtifactReceipt, Catalog, QWEN3_SMALL_ARTIFACT_PATH, QWEN3_SMALL_PROFILE_ID,
QWEN3_SMALL_SOURCE_ID,
};
use crate::{
CompletionOutput, GenerationRequest, LoomSession, Result, session::admit_text,
session::generate,
};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum NativeLogPolicy {
#[default]
Preserve,
Silence,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct LoomOptions {
pub model: ModelOptions,
pub session: SessionOptions,
pub native_logs: NativeLogPolicy,
}
pub struct Loom {
model: Model,
runtime: Runtime,
options: LoomOptions,
profile_artifact: Option<ArtifactReceipt>,
}
impl std::fmt::Debug for Loom {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("Loom")
.field("model", &self.model)
.field("runtime", &self.runtime.compatibility_label())
.field("options", &self.options)
.field("profile_artifact", &self.profile_artifact)
.finish()
}
}
impl Loom {
pub fn load(path: impl AsRef<Path>, options: LoomOptions) -> Result<Self> {
Self::load_inner(path.as_ref(), options, None)
}
pub fn load_qwen3_small(path: impl AsRef<Path>, options: LoomOptions) -> Result<Self> {
let catalog = Catalog::embedded()?;
let catalog_sha256 = catalog.packaged_sha256();
let profile = catalog
.find_profile(QWEN3_SMALL_PROFILE_ID)
.ok_or_else(|| logit_loom_models::ArtifactError::Unknown {
profile: QWEN3_SMALL_PROFILE_ID.to_owned(),
source_id: QWEN3_SMALL_SOURCE_ID.to_owned(),
path: QWEN3_SMALL_ARTIFACT_PATH.to_owned(),
})?;
let verified = profile.verify_artifact(
&catalog_sha256,
QWEN3_SMALL_SOURCE_ID,
QWEN3_SMALL_ARTIFACT_PATH,
path,
)?;
let loaded = Self::load_inner(verified.path(), options, Some(verified.receipt().clone()))?;
profile.verify_artifact(
&catalog_sha256,
QWEN3_SMALL_SOURCE_ID,
QWEN3_SMALL_ARTIFACT_PATH,
verified.path(),
)?;
Ok(loaded)
}
fn load_inner(
path: &Path,
options: LoomOptions,
profile_artifact: Option<ArtifactReceipt>,
) -> Result<Self> {
let mut runtime = Runtime::initialize()?;
if options.native_logs == NativeLogPolicy::Silence {
runtime.silence_native_logs();
}
let model = Model::load(&runtime, path, options.model)?;
Ok(Self {
model,
runtime,
options,
profile_artifact,
})
}
pub const fn options(&self) -> LoomOptions {
self.options
}
pub fn devices(&self) -> &[String] {
self.model.devices()
}
pub const fn model_identity(&self) -> &Digest {
self.model.artifact_digest()
}
pub const fn backend_identity(&self) -> &Digest {
self.runtime.identity()
}
pub fn backend_compatibility(&self) -> &str {
self.runtime.compatibility_label()
}
pub const fn profile_artifact(&self) -> Option<&ArtifactReceipt> {
self.profile_artifact.as_ref()
}
pub const fn raw_model(&self) -> &Model {
&self.model
}
pub const fn raw_runtime(&self) -> &Runtime {
&self.runtime
}
pub fn session(&self) -> Result<LoomSession<'_>> {
self.session_with(self.options.session)
}
pub fn session_with(&self, options: SessionOptions) -> Result<LoomSession<'_>> {
let session = self.model.session(&self.runtime, options)?;
Ok(LoomSession::new(&self.model, session))
}
pub fn load_lora(&self, path: impl AsRef<Path>) -> Result<LoraAdapter> {
self.model.load_lora(path).map_err(Into::into)
}
pub fn complete(
&self,
text: &str,
tokenization: Tokenization,
request: GenerationRequest<'_>,
) -> Result<CompletionOutput> {
let mut session = self.model.session(&self.runtime, self.options.session)?;
let admission = admit_text(&mut session, &self.model, text, tokenization, true, None)?;
let generation = generate(&mut session, request)?;
Ok(CompletionOutput {
admission,
generation,
})
}
}