refactor: remove sys-locale

Cargo.lock

@@ -3993,12 +3993,10 @@ dependencies = [
  "objc2-metal",
  "objc2-metal-performance-shaders",
  "objc2-metal-performance-shaders-graph",
- "once_cell",
  "rustfft",
  "serde",
  "serde_json",
  "strum",
- "sys-locale",
  "tokenizers",
  "tokio",
  "tracing",
@@ -4020,7 +4018,6 @@ dependencies = [
  "serde",
  "serde_bytes",
  "strum",
- "sys-locale",
  "tokio",
  "tracing",
 ]
@@ -4097,7 +4094,6 @@ dependencies = [
  "image",
  "serde",
  "serde_bytes",
- "sys-locale",
  "tokio",
 ]
 
@@ -7345,15 +7341,6 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "sys-locale"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eab9a99a024a169fe8a903cf9d4a3b3601109bcc13bd9e3c6fff259138626c4"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "sysctl"
 version = "0.6.0"

Cargo.toml

@@ -95,7 +95,6 @@ objc2-metal = "0.3"
 objc2-metal-performance-shaders = "0.3"
 objc2-metal-performance-shaders-graph = "0.3"
 objc2-foundation = "0.3"
-sys-locale = "0.3"
 indicatif = "0.18"
 minijinja = "2.16"
 windows = { version = "0.62", features = [

koharu-mcp/src/lib.rs

@@ -112,7 +112,9 @@ impl KoharuMcp {
     #[tool(description = "List available LLM translation models with supported languages")]
     async fn llm_list(&self) -> Result<String, String> {
         let res = self.resources()?;
-        let models = operations::llm_list(res).await.map_err(|e| e.to_string())?;
+        let models = operations::llm_list(res, operations::LlmListPayload { language: None })
+            .await
+            .map_err(|e| e.to_string())?;
         serde_json::to_string_pretty(&models).map_err(|e| e.to_string())
     }
 
@@ -500,7 +502,12 @@ impl KoharuMcp {
             || p.color.is_some()
             || p.shader_effect.is_some()
         {
-            let style = block.style.get_or_insert_with(TextStyle::default);
+            let style = block.style.get_or_insert_with(|| TextStyle {
+                font_families: Vec::new(),
+                font_size: None,
+                color: [0, 0, 0, 255],
+                effect: None,
+            });
 
             if let Some(families) = p.font_families {
                 style.font_families = families;

koharu-ml/Cargo.toml

@@ -29,12 +29,10 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tokio = { workspace = true }
 rustfft = { workspace = true }
-once_cell = { workspace = true }
 futures = { workspace = true }
 num_cpus = { workspace = true }
 libloading = { workspace = true }
 minijinja = { workspace = true }
-sys-locale = { workspace = true }
 cudarc = { workspace = true, optional = true }
 objc2 = { workspace = true, optional = true }
 objc2-metal = { workspace = true, optional = true }

koharu-ml/bin/llm.rs

@@ -1,8 +1,5 @@
 use clap::Parser;
-use koharu_ml::{
-    llm::{GenerateOptions, Llm, ModelId},
-    set_default_locale,
-};
+use koharu_ml::llm::{GenerateOptions, Llm, ModelId, language_from_tag};
 use tracing_subscriber::fmt::format::FmtSpan;
 
 #[derive(Parser, Debug)]
@@ -74,9 +71,8 @@ async fn main() -> anyhow::Result<()> {
 
     let args = Args::parse();
 
-    set_default_locale(args.locale.clone());
-
     let mut llm = Llm::load(args.model, args.cpu).await?;
+    let target_language = language_from_tag(&args.locale);
 
     let opts = GenerateOptions {
         max_tokens: args.max_tokens,
@@ -89,7 +85,7 @@ async fn main() -> anyhow::Result<()> {
         repeat_last_n: args.repeat_last_n,
     };
 
-    let out = llm.generate(&args.prompt, &opts)?;
+    let out = llm.generate(&args.prompt, &opts, Some(target_language))?;
 
     println!("{}", out);
     println!(

koharu-ml/src/facade.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use image::{DynamicImage, Rgba};
-use koharu_types::{Document, FontPrediction, SerializableDynamicImage, TextBlock, TextStyle};
+use koharu_types::{Document, FontPrediction, SerializableDynamicImage, TextBlock};
 
 use crate::comic_text_detector::{self, ComicTextDetector};
 use crate::font_detector::{self, FontDetector};
@@ -126,14 +126,8 @@ impl Model {
 
             let font_predictions = self.detect_fonts(&images, 1).await?;
             for (block, prediction) in doc.text_blocks.iter_mut().zip(font_predictions) {
-                let color = prediction.text_color;
-                let font_size = (prediction.font_size_px > 0.0).then_some(prediction.font_size_px);
                 block.font_prediction = Some(prediction);
-                block.style = Some(TextStyle {
-                    font_size,
-                    color: [color[0], color[1], color[2], 255],
-                    ..Default::default()
-                });
+                block.style = None;
             }
         }
 

koharu-ml/src/lib.rs

@@ -12,7 +12,7 @@ use candle_core::utils::metal_is_available;
 
 pub use candle_core::Device;
 pub use koharu_http::hf_hub::set_cache_dir;
-pub use llm::{language_from_tag, set_default_locale, set_locale, supported_locales};
+pub use llm::{language_from_tag, supported_locales};
 
 pub fn device(cpu: bool) -> Result<Device> {
     if cpu {

koharu-ml/src/llm/facade.rs

@@ -149,13 +149,17 @@ impl Model {
         matches!(*self.state.read().await, State::Ready(_))
     }
 
-    /// Generate text from the loaded model.
-    pub async fn generate(&self, doc: &mut impl Translatable) -> anyhow::Result<()> {
+    /// Translate text using the loaded model.
+    pub async fn translate(
+        &self,
+        doc: &mut impl Translatable,
+        target_language: Option<&str>,
+    ) -> anyhow::Result<()> {
         let mut guard = self.state.write().await;
         match &mut *guard {
             State::Ready(llm) => {
                 let text = doc.get_source()?;
-                let response = llm.generate(&text, &GenerateOptions::default())?;
+                let response = llm.generate(&text, &GenerateOptions::default(), target_language)?;
                 let response = response.trim().to_string();
                 doc.set_translation(response)
             }

koharu-ml/src/llm/mod.rs

@@ -6,7 +6,7 @@ mod quantized_lfm2;
 mod tokenizer;
 
 pub use model::{GenerateOptions, Llm};
-pub use prompt::{ChatMessage, ChatRole, set_default_locale, set_locale};
+pub use prompt::{ChatMessage, ChatRole};
 
 macro_rules! define_languages {
     ( $( $code:literal => $name:literal ),* $(,)? ) => {

koharu-ml/src/llm/model.rs

@@ -136,10 +136,15 @@ impl Llm {
 
     /// Generate up to `max_tokens` following `prompt` using temperature/top-k/p settings.
     /// Logs simple performance metrics via `tracing`.
-    pub fn generate(&mut self, prompt: &str, opts: &GenerateOptions) -> Result<String> {
+    pub fn generate(
+        &mut self,
+        prompt: &str,
+        opts: &GenerateOptions,
+        target_language: Option<&str>,
+    ) -> Result<String> {
         let prompt = self
             .prompt_renderer
-            .format_chat_prompt(prompt.to_string())?;
+            .format_chat_prompt(prompt.to_string(), target_language)?;
         tracing::info!("Generating with prompt:\n{}", prompt);
 
         // Encode prompt

koharu-ml/src/llm/prompt.rs

@@ -1,36 +1,8 @@
 use minijinja::{Environment, context};
-use once_cell::sync::Lazy;
 use serde::Serialize;
-use std::sync::RwLock;
 use strum::{Display, EnumString};
-use sys_locale::get_locale;
 
-use crate::llm::{ModelId, language_from_tag};
-
-static LOCALE: Lazy<RwLock<String>> = Lazy::new(|| RwLock::new(system_locale_name()));
-
-fn system_locale_name() -> String {
-    get_locale()
-        .map(|locale| language_from_tag(&locale).to_string())
-        .unwrap_or_else(|| "English".to_string())
-}
-
-fn get_default_locale() -> String {
-    LOCALE
-        .read()
-        .map(|locale| locale.clone())
-        .unwrap_or_else(|_| system_locale_name())
-}
-
-pub fn set_default_locale(locale: String) {
-    set_locale(locale);
-}
-
-pub fn set_locale(locale: String) {
-    if let Ok(mut guard) = LOCALE.write() {
-        *guard = locale;
-    }
-}
+use crate::llm::ModelId;
 
 #[derive(Debug, Clone, PartialEq, Eq, Display, EnumString)]
 #[strum(serialize_all = "lowercase")]
@@ -99,7 +71,7 @@ impl PromptRenderer {
         }
     }
 
-    fn messages(&self, text: impl Into<String>) -> Vec<ChatMessage> {
+    fn messages(&self, text: impl Into<String>, target_language: Option<&str>) -> Vec<ChatMessage> {
         match self.model_id {
             // refer: https://huggingface.co/lmg-anon/vntl-llama3-8b-v2-gguf#translation-prompt
             ModelId::VntlLlama3_8Bv2 => vec![
@@ -124,15 +96,19 @@ impl PromptRenderer {
                 ChatRole::User,
                 format!(
                     "Translate the following light novel dialog into {}, without additional explanation.\n\n{}",
-                    get_default_locale(),
+                    target_language.unwrap_or("English"),
                     text.into(),
                 ),
             )],
         }
     }
 
-    pub fn format_chat_prompt(&self, prompt: String) -> anyhow::Result<String> {
-        let messages = self.messages(prompt);
+    pub fn format_chat_prompt(
+        &self,
+        prompt: String,
+        target_language: Option<&str>,
+    ) -> anyhow::Result<String> {
+        let messages = self.messages(prompt, target_language);
         let tmpl = self.env.template_from_str(&self.template)?;
 
         let prompt = tmpl
@@ -166,7 +142,7 @@ mod tests {
             "<|begin_of_text|>".to_string(),
             "<|end_of_text|>".to_string(),
         );
-        let formatted = renderer.format_chat_prompt("こんにちは".to_string())?;
+        let formatted = renderer.format_chat_prompt("こんにちは".to_string(), None)?;
         let expected = "<|begin_of_text|><|start_header_id|>Metadata<|end_header_id|>\n\n<|eot_id|><|start_header_id|>Japanese<|end_header_id|>\n\nこんにちは<|eot_id|><|start_header_id|>English<|end_header_id|>\n\n";
         assert_eq!(formatted, expected);
 
@@ -182,7 +158,7 @@ mod tests {
             "<|begin_of_text|>".to_string(),
             "<|end_of_text|>".to_string(),
         );
-        let formatted = renderer.format_chat_prompt("こんにちは".to_string())?;
+        let formatted = renderer.format_chat_prompt("こんにちは".to_string(), None)?;
         let expected = "<|begin_of_text|><|im_start|>system Translate to English, do not add any explanations, do not add or delete line breaks.<|im_end|> <|im_start|>user こんにちは<|im_end|> <|im_start|>assistant ";
         assert_eq!(formatted, expected);
 
@@ -198,7 +174,7 @@ mod tests {
             "<s>".to_string(),
             "</s>".to_string(),
         );
-        let formatted = renderer.format_chat_prompt("こんにちは".to_string())?;
+        let formatted = renderer.format_chat_prompt("こんにちは".to_string(), None)?;
         let expected = "<|im_start|>system 你是一个视觉小说翻译模型，可以通顺地使用给定的术语表以指定的风格将日文翻译成简体中文，并联系上下文正确使用人称代词，注意不要混淆使役态和被动态的主语和宾语，不要擅自添加原文中没有的特殊符号，也不要擅自增加或减少换行。<|im_end|> <|im_start|>user こんにちは<|im_end|> <|im_start|>assistant ";
         assert_eq!(formatted, expected);
 

koharu-ml/tests/llm.rs

@@ -30,7 +30,7 @@ async fn llm_generates_text_for_all_models() -> anyhow::Result<()> {
             repeat_last_n: 64,
         };
 
-        let generated = llm.generate(prompt, &opts)?;
+        let generated = llm.generate(prompt, &opts, None)?;
         assert!(
             !generated.trim().is_empty(),
             "model {model:?} should return some text"

koharu-pipeline/Cargo.toml

@@ -18,6 +18,5 @@ rayon = { workspace = true }
 serde = { workspace = true }
 serde_bytes = { workspace = true }
 strum = { workspace = true }
-sys-locale = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }

koharu-pipeline/src/operations.rs

@@ -6,7 +6,6 @@ use koharu_renderer::renderer::TextShaderEffect;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
-use sys_locale::get_locale;
 use tracing::instrument;
 
 use koharu_types::{Document, SerializableDynamicImage, TextBlock};
@@ -563,16 +562,24 @@ pub async fn list_font_families(state: AppResources) -> anyhow::Result<Vec<Strin
     state.renderer.available_fonts()
 }
 
-pub async fn llm_list(state: AppResources) -> anyhow::Result<Vec<llm::ModelInfo>> {
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LlmListPayload {
+    pub language: Option<String>,
+}
+
+pub async fn llm_list(
+    state: AppResources,
+    payload: LlmListPayload,
+) -> anyhow::Result<Vec<llm::ModelInfo>> {
     let mut models: Vec<ModelId> = ModelId::iter().collect();
     let cpu_factor = if state.llm.is_cpu() { 10 } else { 1 };
-    let zh_locale_factor = match get_locale().unwrap_or_default() {
-        locale if locale.starts_with("zh") => 10,
-        _ => 1,
-    };
-    let non_zh_en_locale_factor = match get_locale().unwrap_or_default() {
-        locale if locale.starts_with("zh") || locale.starts_with("en") => 1,
-        _ => 100,
+    let lang = payload.language.as_deref().unwrap_or("en");
+    let zh_locale_factor = if lang.starts_with("zh") { 10 } else { 1 };
+    let non_zh_en_locale_factor = if lang.starts_with("zh") || lang.starts_with("en") {
+        1
+    } else {
+        100
     };
 
     models.sort_by_key(|m| match m {
@@ -627,11 +634,8 @@ pub async fn llm_generate(state: AppResources, payload: LlmGeneratePayload) -> a
             .ok_or_else(|| anyhow::anyhow!("Document not found"))?
     };
 
-    if let Some(locale) = payload.language.as_ref() {
-        koharu_ml::set_locale(locale.clone());
-    }
-
     let mut updated = snapshot;
+    let target_language = payload.language.as_deref();
 
     match payload.text_block_index {
         Some(bi) => {
@@ -639,10 +643,10 @@ pub async fn llm_generate(state: AppResources, payload: LlmGeneratePayload) -> a
                 .text_blocks
                 .get_mut(bi)
                 .ok_or_else(|| anyhow::anyhow!("Text block not found"))?;
-            state.llm.generate(text_block).await?;
+            state.llm.translate(text_block, target_language).await?;
         }
         None => {
-            state.llm.generate(&mut updated).await?;
+            state.llm.translate(&mut updated, target_language).await?;
         }
     }
 

koharu-pipeline/src/pipeline.rs

@@ -194,10 +194,6 @@ async fn run_pipeline_inner(
         }
     }
 
-    if let Some(locale) = req.language.as_ref() {
-        koharu_ml::set_locale(locale.clone());
-    }
-
     let start_index = req.index.unwrap_or(0);
     let end_index = req.index.map(|i| i + 1).unwrap_or(total_docs);
     let total_steps = PipelineStep::ALL.len();
@@ -237,7 +233,9 @@ async fn run_pipeline_inner(
                 PipelineStep::Ocr => res.ml.ocr(&mut snapshot).await?,
                 PipelineStep::Inpaint => res.ml.inpaint(&mut snapshot).await?,
                 PipelineStep::LlmGenerate => {
-                    res.llm.generate(&mut snapshot).await?;
+                    res.llm
+                        .translate(&mut snapshot, req.language.as_deref())
+                        .await?;
                 }
                 PipelineStep::Render => {
                     res.renderer.render(

koharu-renderer/src/facade.rs

@@ -101,7 +101,12 @@ impl Renderer {
             return Ok(());
         };
 
-        let style = text_block.style.clone().unwrap_or_default();
+        let style = text_block.style.clone().unwrap_or_else(|| TextStyle {
+            font_families: fonts_for_script(translation),
+            font_size: None,
+            color: [0, 0, 0, 255],
+            effect: None,
+        });
         let font = self.select_font(&style)?;
         let block_effect = style.effect.unwrap_or(effect);
         let color = text_block
@@ -196,6 +201,63 @@ fn is_latin_only(text: &str) -> bool {
     })
 }
 
+/// Returns OS-appropriate font family names based on the dominant script in the text.
+fn fonts_for_script(text: &str) -> Vec<String> {
+    let script_map = CodePointMapData::<Script>::new();
+    let has_cjk = text.chars().any(|c| {
+        matches!(
+            script_map.get(c),
+            Script::Han | Script::Hiragana | Script::Katakana | Script::Hangul | Script::Bopomofo
+        )
+    });
+    let has_arabic = text
+        .chars()
+        .any(|c| matches!(script_map.get(c), Script::Arabic | Script::Hebrew));
+
+    let names: &[&str] = if has_cjk {
+        #[cfg(target_os = "windows")]
+        {
+            &["Microsoft YaHei"]
+        }
+        #[cfg(target_os = "macos")]
+        {
+            &["PingFang SC"]
+        }
+        #[cfg(not(any(target_os = "windows", target_os = "macos")))]
+        {
+            &["Noto Sans CJK SC"]
+        }
+    } else if has_arabic {
+        #[cfg(target_os = "windows")]
+        {
+            &["Segoe UI"]
+        }
+        #[cfg(target_os = "macos")]
+        {
+            &["SF Pro"]
+        }
+        #[cfg(not(any(target_os = "windows", target_os = "macos")))]
+        {
+            &["Noto Sans"]
+        }
+    } else {
+        #[cfg(target_os = "windows")]
+        {
+            &["Segoe UI", "Arial"]
+        }
+        #[cfg(target_os = "macos")]
+        {
+            &["SF Pro", "Helvetica"]
+        }
+        #[cfg(not(any(target_os = "windows", target_os = "macos")))]
+        {
+            &["Noto Sans", "DejaVu Sans"]
+        }
+    };
+
+    names.iter().map(|s| s.to_string()).collect()
+}
+
 fn center_layout_horizontally(layout: &mut LayoutRun<'_>, container_width: f32) {
     if !container_width.is_finite() || container_width <= 0.0 {
         return;

koharu-rpc/src/rpc.rs

@@ -92,7 +92,7 @@ async fn dispatch(method: &str, params: rmpv::Value, state: AppResources) -> Res
         "device" => call0(operations::device, state).await,
         "get_documents" => call0(operations::get_documents, state).await,
         "list_font_families" => call0(operations::list_font_families, state).await,
-        "llm_list" => call0(operations::llm_list, state).await,
+        "llm_list" => call(operations::llm_list, state, params).await,
         "llm_ready" => call0(operations::llm_ready, state).await,
         "llm_offload" => call0(operations::llm_offload, state).await,
         "process_cancel" => call0(operations::process_cancel, state).await,

koharu-types/Cargo.toml

@@ -17,5 +17,4 @@ blake3 = { workspace = true }
 image = { workspace = true }
 serde = { workspace = true }
 serde_bytes = { workspace = true }
-sys-locale = { workspace = true }
 tokio = { workspace = true }

koharu-types/src/lib.rs

@@ -6,11 +6,10 @@ pub use effect::TextShaderEffect;
 pub use font::{FontPrediction, NamedFontPrediction, TextDirection};
 pub use image::SerializableDynamicImage;
 
-use std::{collections::HashSet, path::PathBuf, sync::Arc};
+use std::{path::PathBuf, sync::Arc};
 
 use ::image::GenericImageView;
 use serde::{Deserialize, Serialize};
-use sys_locale::get_locale;
 use tokio::sync::RwLock;
 
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
@@ -37,133 +36,6 @@ pub struct TextStyle {
     pub effect: Option<TextShaderEffect>,
 }
 
-impl Default for TextStyle {
-    fn default() -> Self {
-        TextStyle {
-            font_families: default_font_families(),
-            font_size: None,
-            color: [0, 0, 0, 255],
-            effect: None,
-        }
-    }
-}
-
-#[derive(Copy, Clone)]
-enum FontCategory {
-    SimplifiedChinese,
-    TraditionalChinese,
-    English,
-}
-
-fn default_font_families() -> Vec<String> {
-    let locale = get_locale().unwrap_or_default();
-    let priorities = locale_font_priorities(&locale);
-
-    let fonts: Vec<String> = priorities
-        .into_iter()
-        .flat_map(os_font_candidates)
-        .collect();
-
-    dedup_fonts(fonts)
-}
-
-fn locale_font_priorities(locale: &str) -> Vec<FontCategory> {
-    let locale = locale.to_ascii_lowercase();
-    let is_traditional = locale.starts_with("zh")
-        && (locale.contains("tw")
-            || locale.contains("hk")
-            || locale.contains("mo")
-            || locale.contains("hant"));
-    let is_simplified = locale.starts_with("zh")
-        && !is_traditional
-        && (locale.contains("cn")
-            || locale.contains("sg")
-            || locale.contains("my")
-            || locale.contains("hans")
-            || locale == "zh");
-
-    if is_traditional {
-        vec![
-            FontCategory::TraditionalChinese,
-            FontCategory::SimplifiedChinese,
-            FontCategory::English,
-        ]
-    } else if is_simplified {
-        vec![
-            FontCategory::SimplifiedChinese,
-            FontCategory::TraditionalChinese,
-            FontCategory::English,
-        ]
-    } else {
-        vec![
-            FontCategory::English,
-            FontCategory::SimplifiedChinese,
-            FontCategory::TraditionalChinese,
-        ]
-    }
-}
-
-fn os_font_candidates(category: FontCategory) -> Vec<String> {
-    let mut fonts: Vec<&str> = Vec::new();
-    match category {
-        FontCategory::SimplifiedChinese => {
-            #[cfg(target_os = "windows")]
-            {
-                fonts.extend(["Microsoft YaHei"]);
-            }
-            #[cfg(target_os = "macos")]
-            {
-                fonts.extend(["PingFang SC"]);
-            }
-            #[cfg(target_os = "linux")]
-            {
-                fonts.extend(["Noto Sans CJK SC", "Source Han Sans SC"]);
-            }
-        }
-        FontCategory::TraditionalChinese => {
-            #[cfg(target_os = "windows")]
-            {
-                fonts.extend(["Microsoft JhengHei"]);
-            }
-            #[cfg(target_os = "macos")]
-            {
-                fonts.extend(["PingFang TC"]);
-            }
-            #[cfg(target_os = "linux")]
-            {
-                fonts.extend(["Noto Sans CJK TC", "Source Han Sans TC"]);
-            }
-        }
-        FontCategory::English => {
-            #[cfg(target_os = "windows")]
-            {
-                fonts.extend(["Segoe UI", "Arial"]);
-            }
-            #[cfg(target_os = "macos")]
-            {
-                fonts.extend(["SF Pro", "Helvetica"]);
-            }
-            #[cfg(target_os = "linux")]
-            {
-                fonts.extend(["Noto Sans", "DejaVu Sans"]);
-            }
-        }
-    }
-
-    fonts.into_iter().map(str::to_string).collect()
-}
-
-fn dedup_fonts(fonts: Vec<String>) -> Vec<String> {
-    let mut seen = HashSet::new();
-    let mut unique = Vec::new();
-    for font in fonts {
-        if seen.insert(font.to_ascii_lowercase()) {
-            unique.push(font);
-        }
-    }
-    unique
-}
-
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Document {

ui/lib/rpc-types.ts

@@ -68,7 +68,7 @@ export type RpcMethodMap = {
   ]
   update_text_blocks: [{ index: number; textBlocks: TextBlock[] }, void]
   list_font_families: [void, string[]]
-  llm_list: [void, LlmModelInfo[]]
+  llm_list: [{ language?: string }, LlmModelInfo[]]
   llm_load: [{ id: string }, void]
   llm_offload: [void, void]
   llm_ready: [void, boolean]

ui/lib/store.ts

@@ -1,6 +1,7 @@
 'use client'
 
 import { create } from 'zustand'
+import i18n from '@/lib/i18n'
 import {
   invoke,
   subscribeProcessProgress,
@@ -484,7 +485,7 @@ export const useAppStore = create<AppState>((set, get) => {
     },
     llmList: async () => {
       try {
-        const models = await invoke('llm_list')
+        const models = await invoke('llm_list', { language: i18n.language })
         set({ llmModels: models })
         const currentModel = get().llmSelectedModel
         const currentLanguage = get().llmSelectedLanguage