Struct FimEngine 

pub struct FimEngine { /* private fields */ }

A loaded local FIM completion engine. Holds the model in memory; keep one alive and call FimEngine::complete repeatedly.

Implementations

impl FimEngine

pub fn load( cache_dir: &Path, choice: ModelChoice, progress: &(dyn Fn(DownloadProgress) + Sync), ) -> Result<Self, String>

Download (if needed) + load the choice model. cache_dir is where the GGUF weights + tokenizer are cached (see default_cache_dir). progress fires periodically while files download.

Blocking and slow on the first call (a ~1 GB download); fast afterwards (just the load). Run it on a worker thread.

Examples found in repository

examples/smoke.rs (lines 21-27)

fn main() {
    let cache = fim_engine::default_cache_dir();
    let choice = fim_engine::ModelChoice::Qwen1_5B;
    eprintln!("cache dir: {}", cache.display());
    eprintln!(
        "model cached: {}",
        fim_engine::is_model_cached(&cache, choice)
    );

    let t0 = Instant::now();
    let mut engine = match fim_engine::FimEngine::load(&cache, choice, &|p| {
        let pct = p
            .total
            .map(|t| format!("{}%", p.received * 100 / t.max(1)))
            .unwrap_or_else(|| format!("{} bytes", p.received));
        eprintln!("  download {} … {pct}", p.label);
    }) {
        Ok(e) => e,
        Err(e) => {
            eprintln!("LOAD FAILED: {e}");
            std::process::exit(1);
        }
    };
    eprintln!("loaded in {:.1}s", t0.elapsed().as_secs_f64());

    // A classic FIM hole — the body of an `add` function.
    let prefix = "fn add(a: i32, b: i32) -> i32 {\n    ";
    let suffix = "\n}\n";
    let t1 = Instant::now();
    match engine.complete(prefix, suffix, 32) {
        Ok(completion) => {
            eprintln!("completion in {} ms", t1.elapsed().as_millis());
            eprintln!("--- prefix ---\n{prefix}");
            eprintln!("--- COMPLETION ---\n{completion}");
            eprintln!("--- suffix ---\n{suffix}");
        }
        Err(e) => {
            eprintln!("COMPLETE FAILED: {e}");
            std::process::exit(1);
        }
    }
}

pub fn complete( &mut self, prefix: &str, suffix: &str, max_tokens: usize, ) -> Result<String, String>

Generate a completion for the cursor sitting between prefix (code before) and suffix (code after). Returns the text to insert — never includes the surrounding code. max_tokens bounds the length (≈ 64 is a good inline default).

Blocking + CPU-bound (~100–400 ms for the 1.5B model). Call on a worker thread; never on the UI thread.

Examples found in repository

examples/smoke.rs (line 40)

fn main() {
    let cache = fim_engine::default_cache_dir();
    let choice = fim_engine::ModelChoice::Qwen1_5B;
    eprintln!("cache dir: {}", cache.display());
    eprintln!(
        "model cached: {}",
        fim_engine::is_model_cached(&cache, choice)
    );

    let t0 = Instant::now();
    let mut engine = match fim_engine::FimEngine::load(&cache, choice, &|p| {
        let pct = p
            .total
            .map(|t| format!("{}%", p.received * 100 / t.max(1)))
            .unwrap_or_else(|| format!("{} bytes", p.received));
        eprintln!("  download {} … {pct}", p.label);
    }) {
        Ok(e) => e,
        Err(e) => {
            eprintln!("LOAD FAILED: {e}");
            std::process::exit(1);
        }
    };
    eprintln!("loaded in {:.1}s", t0.elapsed().as_secs_f64());

    // A classic FIM hole — the body of an `add` function.
    let prefix = "fn add(a: i32, b: i32) -> i32 {\n    ";
    let suffix = "\n}\n";
    let t1 = Instant::now();
    match engine.complete(prefix, suffix, 32) {
        Ok(completion) => {
            eprintln!("completion in {} ms", t1.elapsed().as_millis());
            eprintln!("--- prefix ---\n{prefix}");
            eprintln!("--- COMPLETION ---\n{completion}");
            eprintln!("--- suffix ---\n{suffix}");
        }
        Err(e) => {
            eprintln!("COMPLETE FAILED: {e}");
            std::process::exit(1);
        }
    }
}