refactor: rewrite backend storage, config, and runtime

Cargo.lock

@@ -3908,6 +3908,7 @@ name = "koharu"
 version = "0.41.4"
 dependencies = [
  "anyhow",
+ "camino",
  "clap",
  "dirs",
  "git-version",
@@ -3923,6 +3924,7 @@ dependencies = [
  "serde_json",
  "tauri",
  "tauri-build",
+ "tauri-plugin-process",
  "tauri-plugin-updater",
  "tokio",
  "tracing",
@@ -3937,6 +3939,8 @@ name = "koharu-app"
 version = "0.41.4"
 dependencies = [
  "anyhow",
+ "blake3",
+ "camino",
  "dirs",
  "image",
  "imageproc",
@@ -3945,13 +3949,13 @@ dependencies = [
  "koharu-ml",
  "koharu-renderer",
  "koharu-runtime",
- "once_cell",
+ "lru",
  "open",
  "rayon",
  "reqwest-middleware",
  "rfd",
  "serde",
- "serde_bytes",
+ "serde_json",
  "strum",
  "tempfile",
  "tokio",
@@ -4119,6 +4123,7 @@ version = "0.41.4"
 dependencies = [
  "anyhow",
  "axum",
+ "camino",
  "dirs",
  "flate2",
  "futures",
@@ -4324,6 +4329,15 @@ dependencies = [
  "imgref",
 ]
 
+[[package]]
+name = "lru"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f8cc7106155f10bdf99a6f379688f543ad6596a415375b36a59a054ceda1198"
+dependencies = [
+ "hashbrown 0.15.5",
+]
+
 [[package]]
 name = "lru-slab"
 version = "0.1.2"
@@ -7640,6 +7654,16 @@ dependencies = [
  "walkdir",
 ]
 
+[[package]]
+name = "tauri-plugin-process"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d55511a7bf6cd70c8767b02c97bf8134fa434daf3926cfc1be0a0f94132d165a"
+dependencies = [
+ "tauri",
+ "tauri-plugin",
+]
+
 [[package]]
 name = "tauri-plugin-updater"
 version = "2.10.0"

Cargo.toml

@@ -74,6 +74,7 @@ toml = "1.1"
 inventory = "0.3"
 url = { version = "2.5", features = ["serde"] }
 arc-swap = "1.7"
+camino = { version = "1.1", features = ["serde1"] }
 indexmap = "2.11"
 flate2 = { version = "1.0", default-features = false, features = [
     "zlib-ng-compat",
@@ -134,6 +135,8 @@ tower-http = { version = "0.6", features = ["cors"] }
 criterion = { version = "0.8", features = ["html_reports"] }
 git-version = "0.3"
 keyring = "3.6"
+lru = "0.14"
+tauri-plugin-process = "2.3"
 
 [patch.crates-io]
 candle-transformers = { git = "https://github.com/mayocream/candle", branch = "cuda-dynamic-loading" }

bun.lock

@@ -32,6 +32,7 @@
         "@tanstack/react-query": "^5.96.1",
         "@tanstack/react-virtual": "^3.13.23",
         "@tauri-apps/api": "^2.10.1",
+        "@tauri-apps/plugin-process": "^2.3.1",
         "@use-gesture/react": "^10.3.1",
         "@xstate/react": "^6.1.0",
         "browser-fs-access": "^0.38.0",
@@ -432,6 +433,8 @@
 
     "@tauri-apps/cli-win32-x64-msvc": ["@tauri-apps/cli-win32-x64-msvc@2.10.1", "", { "os": "win32", "cpu": "x64" }, "sha512-6Cn7YpPFwzChy0ERz6djKEmUehWrYlM+xTaNzGPgZocw3BD7OfwfWHKVWxXzdjEW2KfKkHddfdxK1XXTYqBRLg=="],
 
+    "@tauri-apps/plugin-process": ["@tauri-apps/plugin-process@2.3.1", "", { "dependencies": { "@tauri-apps/api": "^2.8.0" } }, "sha512-nCa4fGVaDL/B9ai03VyPOjfAHRHSBz5v6F/ObsB73r/dA3MHHhZtldaDMIc0V/pnUw9ehzr2iEG+XkSEyC0JJA=="],
+
     "@types/debug": ["@types/debug@4.1.12", "", { "dependencies": { "@types/ms": "*" } }, "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ=="],
 
     "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],

docs/en-US/reference/http-api.md

@@ -120,24 +120,24 @@ Single-document export endpoints return binary file content. Bulk export returns
 
 | Method | Path | Purpose |
 | --- | --- | --- |
-| `GET` | `/llm/models` | list local and API-backed translation models |
-| `GET` | `/llm/state` | get the current LLM status |
-| `POST` | `/llm/load` | load a local or API-backed model |
-| `POST` | `/llm/offload` | unload the current model |
-| `POST` | `/llm/ping` | test an OpenAI-compatible base URL |
+| `GET` | `/llm/catalog` | list the grouped local/provider LLM catalog |
+| `GET` | `/llm` | get the current LLM status |
+| `PUT` | `/llm` | load a local or provider-backed model target |
+| `DELETE` | `/llm` | unload the current model |
 
 Useful request details:
 
-- `/llm/models` accepts optional `language` and `openaiCompatibleBaseUrl` query parameters
-- `/llm/load` accepts `id`, `apiKey`, `baseUrl`, `temperature`, `maxTokens`, and `customSystemPrompt`
-- `/llm/ping` accepts `baseUrl` and optional `apiKey`
+- `/llm/catalog` accepts optional `language`
+- `PUT /llm` accepts `target` plus optional `options { temperature, maxTokens, customSystemPrompt }`
+- provider targets use `{ kind: "provider", providerId, modelId }`; local targets use `{ kind: "local", modelId }`
 
-## Provider API keys
+## Provider configuration
 
-| Method | Path | Purpose |
-| --- | --- | --- |
-| `GET` | `/providers/{provider}/api-key` | read a saved API key for a provider |
-| `PUT` | `/providers/{provider}/api-key` | store or overwrite a provider API key |
+Provider settings now live under `GET /config` and `PUT /config`.
+
+- non-secret provider fields such as `baseUrl` are stored in `llm.providers`
+- provider reads expose `hasApiKey`, not the raw saved key
+- provider updates can set or clear API keys through `PUT /config`
 
 Current built-in provider ids include:
 
@@ -157,7 +157,7 @@ Current built-in provider ids include:
 The pipeline job request can include:
 
 - `documentId` to target one page, or omit it to process all loaded pages
-- LLM settings such as `llmModelId`, `llmApiKey`, `llmBaseUrl`, `llmTemperature`, `llmMaxTokens`, and `llmCustomSystemPrompt`
+- `llm { target, options }` to choose a local/provider model and optional generation overrides
 - render settings such as `shaderEffect`, `shaderStroke`, and `fontFamily`
 - `language`
 
@@ -187,7 +187,7 @@ The normal API order for one page is:
 1. `POST /documents/import?mode=replace`
 2. `POST /documents/{documentId}/detect`
 3. `POST /documents/{documentId}/ocr`
-4. `POST /llm/load`
+4. `PUT /llm`
 5. `POST /documents/{documentId}/translate`
 6. `POST /documents/{documentId}/inpaint`
 7. `POST /documents/{documentId}/render`

docs/en-US/reference/mcp-tools.md

@@ -71,7 +71,7 @@ Valid `view_text_block` layers:
 | `ocr` | run OCR on detected blocks | `index` |
 | `inpaint` | remove text using the current mask | `index` |
 | `render` | draw translated text back onto the page | `index`, optional `text_block_index`, `shader_effect`, `font_family` |
-| `process` | start detect -> OCR -> inpaint -> translate -> render | optional `index`, `llm_model_id`, `language`, `shader_effect`, `font_family` |
+| `process` | start detect -> OCR -> inpaint -> translate -> render | optional `document_id`, `llm_target`, `language`, `shader_effect`, `font_family` |
 
 `process` is the coarse-grained convenience tool. If you need more control or easier debugging, use the stage tools separately.
 
@@ -79,7 +79,7 @@ Valid `view_text_block` layers:
 
 | Tool | What it does | Key parameters |
 | --- | --- | --- |
-| `llm_load` | load a translation model | `id`, optional `temperature`, `max_tokens`, `custom_system_prompt` |
+| `llm_load` | load a translation model target | `target`, optional `options.temperature`, `options.max_tokens`, `options.custom_system_prompt` |
 | `llm_offload` | unload the current model | none |
 | `llm_generate` | translate one block or all blocks | `index`, optional `text_block_index`, `language` |
 

docs/ja-JP/reference/http-api.md

@@ -120,24 +120,24 @@ import エンドポイントは、`files` フィールドを繰り返し持つ m
 
 | Method | Path | 目的 |
 | --- | --- | --- |
-| `GET` | `/llm/models` | ローカルおよび API ベースの翻訳モデル一覧を取得する |
-| `GET` | `/llm/state` | 現在の LLM 状態を取得する |
-| `POST` | `/llm/load` | ローカルまたは API ベースのモデルを読み込む |
-| `POST` | `/llm/offload` | 現在のモデルをアンロードする |
-| `POST` | `/llm/ping` | OpenAI 互換 base URL を接続確認する |
+| `GET` | `/llm/catalog` | ローカル/プロバイダ別に整理された LLM カタログを取得する |
+| `GET` | `/llm` | 現在の LLM 状態を取得する |
+| `PUT` | `/llm` | ローカルまたはプロバイダ target を読み込む |
+| `DELETE` | `/llm` | 現在のモデルをアンロードする |
 
 実用上のリクエスト詳細:
 
-- `/llm/models` は `language` と `openaiCompatibleBaseUrl` の query parameter を任意で受け付けます
-- `/llm/load` は `id`、`apiKey`、`baseUrl`、`temperature`、`maxTokens`、`customSystemPrompt` を受け付けます
-- `/llm/ping` は `baseUrl` と任意の `apiKey` を受け付けます
+- `/llm/catalog` は任意で `language` を受け付けます
+- `PUT /llm` は `target` と任意の `options { temperature, maxTokens, customSystemPrompt }` を受け付けます
+- provider target は `{ kind: "provider", providerId, modelId }`、local target は `{ kind: "local", modelId }` です
 
-## プロバイダ API キー
+## プロバイダ設定
 
-| Method | Path | 目的 |
-| --- | --- | --- |
-| `GET` | `/providers/{provider}/api-key` | 保存済みの API キーを読み出す |
-| `PUT` | `/providers/{provider}/api-key` | プロバイダ API キーを保存または上書きする |
+プロバイダ設定は `GET /config` と `PUT /config` に統合されました。
+
+- `llm.providers` に `baseUrl` などの非シークレット設定を保存します
+- 読み出しでは生の API キーは返さず、`hasApiKey` のみ返します
+- API キーの設定/削除も `PUT /config` で行います
 
 現在の組み込み provider id は次です。
 
@@ -157,7 +157,7 @@ import エンドポイントは、`files` フィールドを繰り返し持つ m
 pipeline job リクエストには次を含められます。
 
 - `documentId` を指定すると 1 ページ対象、省略すると読み込み済み全ページ対象
-- `llmModelId`、`llmApiKey`、`llmBaseUrl`、`llmTemperature`、`llmMaxTokens`、`llmCustomSystemPrompt` などの LLM 設定
+- `llm { target, options }` による LLM 選択と任意の生成オプション
 - `shaderEffect`、`shaderStroke`、`fontFamily` などの render 設定
 - `language`
 

docs/ja-JP/reference/mcp-tools.md

@@ -71,7 +71,7 @@ http://127.0.0.1:<PORT>/mcp
 | `ocr` | 検出済みブロックに OCR をかける | `index` |
 | `inpaint` | 現在の mask を使って文字を除去する | `index` |
 | `render` | 翻訳済みテキストをページに描き戻す | `index`, 任意で `text_block_index`, `shader_effect`, `font_family` |
-| `process` | detect -> OCR -> inpaint -> translate -> render をまとめて開始する | 任意で `index`, `llm_model_id`, `language`, `shader_effect`, `font_family` |
+| `process` | detect -> OCR -> inpaint -> translate -> render をまとめて開始する | 任意で `document_id`, `llm_target`, `language`, `shader_effect`, `font_family` |
 
 `process` は粗粒度の convenience tool です。より細かな制御や切り分けが必要なら、各段階ツールを個別に使ってください。
 
@@ -79,7 +79,7 @@ http://127.0.0.1:<PORT>/mcp
 
 | Tool | 役割 | 主な引数 |
 | --- | --- | --- |
-| `llm_load` | 翻訳モデルを読み込む | `id`, 任意で `temperature`, `max_tokens`, `custom_system_prompt` |
+| `llm_load` | 翻訳モデル target を読み込む | `target`, 任意で `options.temperature`, `options.max_tokens`, `options.custom_system_prompt` |
 | `llm_offload` | 現在のモデルをアンロードする | なし |
 | `llm_generate` | 1 ブロックまたは全ブロックを翻訳する | `index`, 任意で `text_block_index`, `language` |
 

docs/zh-CN/reference/http-api.md

@@ -120,24 +120,24 @@ http://127.0.0.1:<PORT>/api/v1
 
 | 方法 | 路径 | 用途 |
 | --- | --- | --- |
-| `GET` | `/llm/models` | 列出本地与 API 支持的翻译模型 |
-| `GET` | `/llm/state` | 获取当前 LLM 状态 |
-| `POST` | `/llm/load` | 加载本地或 API 模型 |
-| `POST` | `/llm/offload` | 卸载当前模型 |
-| `POST` | `/llm/ping` | 测试 OpenAI 兼容 base URL |
+| `GET` | `/llm/catalog` | 获取按本地/提供商分组的 LLM 目录 |
+| `GET` | `/llm` | 获取当前 LLM 状态 |
+| `PUT` | `/llm` | 加载本地或提供商 target |
+| `DELETE` | `/llm` | 卸载当前模型 |
 
 常用请求细节：
 
-- `/llm/models` 支持可选查询参数 `language` 和 `openaiCompatibleBaseUrl`
-- `/llm/load` 接受 `id`、`apiKey`、`baseUrl`、`temperature`、`maxTokens` 和 `customSystemPrompt`
-- `/llm/ping` 接受 `baseUrl` 以及可选 `apiKey`
+- `/llm/catalog` 支持可选查询参数 `language`
+- `PUT /llm` 接受 `target` 与可选 `options { temperature, maxTokens, customSystemPrompt }`
+- provider target 使用 `{ kind: "provider", providerId, modelId }`，local target 使用 `{ kind: "local", modelId }`
 
-### 提供商 API Key
+### 提供商配置
 
-| 方法 | 路径 | 用途 |
-| --- | --- | --- |
-| `GET` | `/providers/{provider}/api-key` | 读取已保存的提供商 API key |
-| `PUT` | `/providers/{provider}/api-key` | 存储或覆盖 API key |
+提供商设置现在统一放在 `GET /config` 和 `PUT /config` 中。
+
+- `llm.providers` 保存 `baseUrl` 等非秘密配置
+- 读取配置时只返回 `hasApiKey`，不会返回原始 API key
+- 设置或清除 API key 也通过 `PUT /config` 完成
 
 当前内置 provider id 包括：
 
@@ -157,7 +157,7 @@ http://127.0.0.1:<PORT>/api/v1
 管线任务请求可以包含：
 
 - `documentId`：只处理某一页；留空时处理所有已加载页面
-- LLM 设置，例如 `llmModelId`、`llmApiKey`、`llmBaseUrl`、`llmTemperature`、`llmMaxTokens`、`llmCustomSystemPrompt`
+- `llm { target, options }`：选择 LLM 目标以及可选生成参数
 - 渲染设置，例如 `shaderEffect`、`shaderStroke`、`fontFamily`
 - `language`
 

docs/zh-CN/reference/mcp-tools.md

@@ -71,7 +71,7 @@ http://127.0.0.1:<PORT>/mcp
 | `ocr` | 对检测块执行 OCR | `index` |
 | `inpaint` | 使用当前掩码去除文字 | `index` |
 | `render` | 把译文绘制回页面 | `index`、可选 `text_block_index`、`shader_effect`、`font_family` |
-| `process` | 依次执行 detect -> OCR -> inpaint -> translate -> render | 可选 `index`、`llm_model_id`、`language`、`shader_effect`、`font_family` |
+| `process` | 依次执行 detect -> OCR -> inpaint -> translate -> render | 可选 `document_id`、`llm_target`、`language`、`shader_effect`、`font_family` |
 
 `process` 是粗粒度的便捷工具。如果你想要更细的控制或更好排查问题，建议拆开使用各阶段工具。
 
@@ -79,7 +79,7 @@ http://127.0.0.1:<PORT>/mcp
 
 | 工具 | 作用 | 关键参数 |
 | --- | --- | --- |
-| `llm_load` | 加载一个翻译模型 | `id`、可选 `temperature`、`max_tokens`、`custom_system_prompt` |
+| `llm_load` | 加载一个翻译模型 target | `target`、可选 `options.temperature`、`options.max_tokens`、`options.custom_system_prompt` |
 | `llm_offload` | 卸载当前模型 | 无 |
 | `llm_generate` | 翻译单个文本块或全部文本块 | `index`、可选 `text_block_index`、`language` |
 

koharu-app/Cargo.toml

@@ -18,16 +18,15 @@ koharu-renderer = { workspace = true }
 koharu-llm = { workspace = true }
 koharu-runtime = { workspace = true }
 anyhow = { workspace = true }
+camino = { workspace = true }
 dirs = { workspace = true }
 image = { workspace = true }
 imageproc = { workspace = true }
-once_cell = { workspace = true }
 open = { workspace = true }
 rayon = { workspace = true }
 rfd = { workspace = true }
 reqwest-middleware = { workspace = true }
 serde = { workspace = true }
-serde_bytes = { workspace = true }
 strum = { workspace = true }
 tempfile = { workspace = true }
 tokio = { workspace = true }
@@ -35,3 +34,6 @@ toml = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
 uuid = { workspace = true }
+blake3 = { workspace = true }
+lru = { workspace = true }
+serde_json = { workspace = true }

koharu-app/src/blob_store.rs

@@ -0,0 +1,46 @@
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+
+#[derive(Clone)]
+pub struct BlobStore {
+    root: PathBuf,
+}
+
+impl BlobStore {
+    pub fn new(root: impl Into<PathBuf>) -> Result<Self> {
+        let root = root.into();
+        std::fs::create_dir_all(&root)?;
+        Ok(Self { root })
+    }
+
+    /// Write bytes to the store, return the blake3 hash hex string.
+    pub fn put(&self, data: &[u8]) -> Result<String> {
+        let hash = blake3::hash(data).to_hex().to_string();
+        let path = self.blob_path(&hash);
+        if path.exists() {
+            return Ok(hash); // already stored (content-addressable)
+        }
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        std::fs::write(&path, data).with_context(|| format!("Failed to write blob {hash}"))?;
+        Ok(hash)
+    }
+
+    /// Read bytes from the store by hash.
+    pub fn get(&self, hash: &str) -> Result<Vec<u8>> {
+        let path = self.blob_path(hash);
+        std::fs::read(&path).with_context(|| format!("Blob not found: {hash}"))
+    }
+
+    /// Check if a blob exists.
+    pub fn exists(&self, hash: &str) -> bool {
+        self.blob_path(hash).exists()
+    }
+
+    fn blob_path(&self, hash: &str) -> PathBuf {
+        let (prefix, rest) = hash.split_at(2.min(hash.len()));
+        self.root.join(prefix).join(rest)
+    }
+}

koharu-app/src/config.rs

@@ -1,65 +1,97 @@
+use std::collections::{BTreeMap, HashSet};
 use std::fs;
 use std::io::Write;
-use std::path::PathBuf;
 
 use anyhow::{Context, Result};
-use koharu_core::{BootstrapConfig, BootstrapHttpConfig, BootstrapPathConfig};
-use koharu_runtime::Settings;
+use camino::{Utf8Path, Utf8PathBuf};
+use koharu_core::{
+    AppConfig as PublicAppConfig, AppConfigUpdate, AppDataConfig, AppLlmConfig,
+    AppLlmProviderConfig, AppLlmProviderConfigUpdate,
+};
+use koharu_llm::providers::{
+    all_provider_descriptors, find_provider_descriptor, get_saved_api_key, set_saved_api_key,
+};
+use koharu_runtime::default_app_data_root;
+use serde::{Deserialize, Serialize};
 use tempfile::NamedTempFile;
-use url::Url;
 
-const CONFIG_DIR: &str = ".koharu";
 const CONFIG_FILE: &str = "config.toml";
+const MANAGED_DATA_DIRS: &[&str] = &["runtime", "models", "blobs", "pages"];
 
-pub type AppConfig = Settings;
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(default)]
+pub struct StoredConfig {
+    pub data: StoredDataConfig,
+    pub llm: StoredLlmConfig,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(default)]
+pub struct StoredDataConfig {
+    pub path: Utf8PathBuf,
+}
 
-pub fn config_dir() -> Result<PathBuf> {
-    let home =
-        dirs::home_dir().ok_or_else(|| anyhow::anyhow!("failed to resolve home directory"))?;
-    Ok(home.join(CONFIG_DIR))
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(default)]
+pub struct StoredLlmConfig {
+    pub providers: BTreeMap<String, StoredProviderConfig>,
 }
 
-pub fn config_path() -> Result<PathBuf> {
-    Ok(config_dir()?.join(CONFIG_FILE))
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(default)]
+pub struct StoredProviderConfig {
+    pub base_url: Option<String>,
 }
 
-pub fn load() -> Result<AppConfig> {
+impl Default for StoredDataConfig {
+    fn default() -> Self {
+        Self {
+            path: default_app_data_root(),
+        }
+    }
+}
+
+pub fn config_path() -> Result<Utf8PathBuf> {
+    Ok(default_app_data_root().join(CONFIG_FILE))
+}
+
+pub fn load() -> Result<StoredConfig> {
     let path = config_path()?;
     if !path.exists() {
-        return Ok(AppConfig::default());
+        let config = StoredConfig::default();
+        save(&config)?;
+        return Ok(config);
     }
 
-    let content = fs::read_to_string(&path)
-        .with_context(|| format!("failed to read `{}`", path.display()))?;
-    toml::from_str(&content).with_context(|| format!("failed to parse `{}`", path.display()))
+    let content = fs::read_to_string(&path).with_context(|| format!("failed to read `{path}`"))?;
+    toml::from_str(&content).with_context(|| format!("failed to parse `{path}`"))
 }
 
-pub fn save(config: &AppConfig) -> Result<()> {
-    let dir = config_dir()?;
-    fs::create_dir_all(&dir)
-        .with_context(|| format!("failed to create config dir `{}`", dir.display()))?;
+pub fn save(config: &StoredConfig) -> Result<()> {
+    let path = config_path()?;
+    let dir = path
+        .parent()
+        .ok_or_else(|| anyhow::anyhow!("config path `{path}` does not have a parent directory"))?;
+    fs::create_dir_all(dir).with_context(|| format!("failed to create config dir `{dir}`"))?;
 
-    let path = dir.join(CONFIG_FILE);
     let content = toml::to_string_pretty(config).context("failed to serialize app config")?;
-    let mut temp = NamedTempFile::new_in(&dir)
-        .with_context(|| format!("failed to stage `{}`", path.display()))?;
+    let mut temp =
+        NamedTempFile::new_in(dir).with_context(|| format!("failed to stage `{path}`"))?;
     temp.write_all(content.as_bytes())
-        .with_context(|| format!("failed to write temp config for `{}`", path.display()))?;
+        .with_context(|| format!("failed to write temp config for `{path}`"))?;
     temp.flush()
-        .with_context(|| format!("failed to flush temp config for `{}`", path.display()))?;
+        .with_context(|| format!("failed to flush temp config for `{path}`"))?;
 
     match temp.persist(&path) {
         Ok(_) => Ok(()),
         Err(err) => {
             if path.exists() {
-                fs::remove_file(&path).with_context(|| {
-                    format!("failed to replace existing config `{}`", path.display())
-                })?;
+                fs::remove_file(&path)
+                    .with_context(|| format!("failed to replace existing config `{path}`"))?;
             }
             err.file.persist(&path).map(|_| ()).map_err(|persist_err| {
                 anyhow::anyhow!(
-                    "failed to persist config to `{}`: {}",
-                    path.display(),
+                    "failed to persist config to `{path}`: {}",
                     persist_err.error
                 )
             })
@@ -67,141 +99,298 @@ pub fn save(config: &AppConfig) -> Result<()> {
     }
 }
 
-pub fn to_bootstrap_config(config: &AppConfig) -> BootstrapConfig {
-    BootstrapConfig {
-        runtime: BootstrapPathConfig {
-            path: config.runtime.path.to_string_lossy().to_string(),
-        },
-        models: BootstrapPathConfig {
-            path: config.models.path.to_string_lossy().to_string(),
-        },
-        http: BootstrapHttpConfig {
-            proxy: config.http_proxy().map(Url::to_string),
+pub fn to_public_config(config: &StoredConfig) -> Result<PublicAppConfig> {
+    let mut providers = Vec::new();
+    for descriptor in all_provider_descriptors() {
+        let stored = config.llm.providers.get(descriptor.id);
+        let has_api_key = get_saved_api_key(descriptor.id)?
+            .map(|value| !value.trim().is_empty())
+            .unwrap_or(false);
+        providers.push(AppLlmProviderConfig {
+            id: descriptor.id.to_string(),
+            base_url: stored.and_then(|provider| provider.base_url.clone()),
+            has_api_key,
+        });
+    }
+
+    Ok(PublicAppConfig {
+        data: AppDataConfig {
+            path: config.data.path.to_string(),
         },
+        llm: AppLlmConfig { providers },
+    })
+}
+
+pub fn from_public_update(config: AppConfigUpdate) -> Result<StoredConfig> {
+    validate_provider_updates(&config)?;
+
+    let data_path = config.data.path.trim();
+    anyhow::ensure!(!data_path.is_empty(), "data path is required");
+    let data_path = Utf8PathBuf::from(data_path);
+    anyhow::ensure!(data_path.is_absolute(), "data path must be absolute");
+
+    let mut providers = BTreeMap::new();
+    for provider in config.llm.providers {
+        let id = provider.id.trim();
+        let descriptor = find_provider_descriptor(id)
+            .ok_or_else(|| anyhow::anyhow!("unknown provider id: {id}"))?;
+        let base_url = normalized_base_url(&provider);
+
+        if base_url.is_some()
+            || provider.api_key.is_some()
+            || provider.clear_api_key
+            || descriptor.requires_base_url
+        {
+            providers.insert(id.to_string(), StoredProviderConfig { base_url });
+        }
     }
+
+    Ok(StoredConfig {
+        data: StoredDataConfig { path: data_path },
+        llm: StoredLlmConfig { providers },
+    })
 }
 
-pub fn from_bootstrap_config(config: BootstrapConfig) -> Result<AppConfig> {
-    let runtime_path = config.runtime.path.trim();
-    let models_path = config.models.path.trim();
-    anyhow::ensure!(!runtime_path.is_empty(), "runtime path is required");
-    anyhow::ensure!(!models_path.is_empty(), "models path is required");
+pub fn move_app_data_if_needed(current: &StoredConfig, next: &StoredConfig) -> Result<bool> {
+    if same_path(&current.data.path, &next.data.path) {
+        return Ok(false);
+    }
+
+    fs::create_dir_all(&next.data.path)
+        .with_context(|| format!("failed to create `{}`", next.data.path))?;
+
+    for name in MANAGED_DATA_DIRS {
+        move_path(
+            current.data.path.join(name).as_std_path(),
+            next.data.path.join(name).as_std_path(),
+        )?;
+    }
+
+    Ok(true)
+}
+
+pub fn apply_secret_updates(config: &AppConfigUpdate) -> Result<()> {
+    validate_provider_updates(config)?;
+
+    for provider in &config.llm.providers {
+        let id = provider.id.trim();
+        let api_key = provider.api_key.as_deref().map(str::trim);
+        let should_clear = provider.clear_api_key || matches!(api_key, Some(""));
+        if should_clear {
+            set_saved_api_key(id, "")?;
+            continue;
+        }
+        if let Some(api_key) = api_key
+            && !api_key.is_empty()
+        {
+            set_saved_api_key(id, api_key)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn same_path(left: &Utf8Path, right: &Utf8Path) -> bool {
+    match (
+        fs::canonicalize(left.as_std_path()),
+        fs::canonicalize(right.as_std_path()),
+    ) {
+        (Ok(left), Ok(right)) => left == right,
+        _ => left == right,
+    }
+}
+
+fn move_path(source: &std::path::Path, destination: &std::path::Path) -> Result<()> {
+    if !source.exists() {
+        return Ok(());
+    }
+
+    if let Some(parent) = destination.parent() {
+        fs::create_dir_all(parent)
+            .with_context(|| format!("failed to create `{}`", parent.display()))?;
+    }
+
+    if !destination.exists() && fs::rename(source, destination).is_ok() {
+        return Ok(());
+    }
+
+    if source.is_dir() {
+        fs::create_dir_all(destination)
+            .with_context(|| format!("failed to create `{}`", destination.display()))?;
 
-    let proxy = config
-        .http
-        .proxy
+        for entry in fs::read_dir(source)
+            .with_context(|| format!("failed to read `{}`", source.display()))?
+        {
+            let entry = entry.with_context(|| format!("failed to read `{}`", source.display()))?;
+            move_path(&entry.path(), &destination.join(entry.file_name()))?;
+        }
+
+        fs::remove_dir_all(source)
+            .with_context(|| format!("failed to remove `{}`", source.display()))?;
+    } else {
+        if destination.exists() {
+            fs::remove_file(destination)
+                .with_context(|| format!("failed to replace `{}`", destination.display()))?;
+        }
+        fs::copy(source, destination).with_context(|| {
+            format!(
+                "failed to copy `{}` to `{}`",
+                source.display(),
+                destination.display()
+            )
+        })?;
+        fs::remove_file(source)
+            .with_context(|| format!("failed to remove `{}`", source.display()))?;
+    }
+
+    Ok(())
+}
+fn normalized_base_url(provider: &AppLlmProviderConfigUpdate) -> Option<String> {
+    provider
+        .base_url
         .as_deref()
         .map(str::trim)
         .filter(|value| !value.is_empty())
-        .map(Url::parse)
-        .transpose()
-        .context("invalid HTTP proxy URL")?;
+        .map(ToOwned::to_owned)
+}
 
-    Ok(
-        AppConfig::from_paths(PathBuf::from(runtime_path), PathBuf::from(models_path))
-            .with_proxy(proxy),
-    )
+fn validate_provider_updates(config: &AppConfigUpdate) -> Result<()> {
+    let mut seen = HashSet::new();
+    for provider in &config.llm.providers {
+        let id = provider.id.trim();
+        anyhow::ensure!(!id.is_empty(), "provider id is required");
+        anyhow::ensure!(
+            find_provider_descriptor(id).is_some(),
+            "unknown provider id: {id}"
+        );
+        anyhow::ensure!(seen.insert(id.to_string()), "duplicate provider id: {id}");
+        anyhow::ensure!(
+            !(provider.clear_api_key
+                && provider
+                    .api_key
+                    .as_deref()
+                    .map(str::trim)
+                    .is_some_and(|value| !value.is_empty())),
+            "provider {id} cannot set and clear api_key in the same update"
+        );
+    }
+
+    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
-    use std::env;
-    use std::path::Path;
+    use std::fs;
+
+    use camino::Utf8PathBuf;
+    use koharu_core::{
+        AppConfigUpdate, AppDataConfigUpdate, AppLlmConfigUpdate, AppLlmProviderConfigUpdate,
+    };
 
     use super::{
-        AppConfig, BootstrapConfig, BootstrapHttpConfig, BootstrapPathConfig,
-        from_bootstrap_config, to_bootstrap_config,
+        StoredConfig, config_path, from_public_update, move_app_data_if_needed, to_public_config,
     };
 
     #[test]
-    fn bootstrap_round_trip_preserves_paths_and_proxy() {
-        let config = BootstrapConfig {
-            runtime: BootstrapPathConfig {
-                path: "/tmp/runtime".to_string(),
-            },
-            models: BootstrapPathConfig {
-                path: "/tmp/models".to_string(),
-            },
-            http: BootstrapHttpConfig {
-                proxy: Some("http://127.0.0.1:7890".to_string()),
-            },
-        };
+    fn old_config_without_data_section_still_loads() {
+        let config: StoredConfig = toml::from_str(
+            r#"
+                [runtime]
+                path = "/tmp/runtime"
 
-        let app = from_bootstrap_config(config.clone()).unwrap();
-        let serialized = to_bootstrap_config(&app);
+                [models]
+                path = "/tmp/models"
 
-        assert_eq!(serialized.runtime.path, config.runtime.path);
-        assert_eq!(serialized.models.path, config.models.path);
-        assert_eq!(
-            serialized
-                .http
-                .proxy
-                .as_deref()
-                .map(url::Url::parse)
-                .transpose()
-                .unwrap(),
-            config
-                .http
-                .proxy
-                .as_deref()
-                .map(url::Url::parse)
-                .transpose()
-                .unwrap()
-        );
+                [http]
+                proxy = "http://127.0.0.1:7890"
+            "#,
+        )
+        .unwrap();
+
+        assert_eq!(config.data.path, koharu_runtime::default_app_data_root());
+        assert!(config.llm.providers.is_empty());
     }
 
     #[test]
-    fn blank_proxy_becomes_none() {
-        let app = from_bootstrap_config(BootstrapConfig {
-            runtime: BootstrapPathConfig {
-                path: ".".to_string(),
+    fn public_update_round_trip_preserves_fields() {
+        let config = from_public_update(AppConfigUpdate {
+            data: AppDataConfigUpdate {
+                path: "/tmp/koharu-data".to_string(),
             },
-            models: BootstrapPathConfig {
-                path: ".".to_string(),
-            },
-            http: BootstrapHttpConfig {
-                proxy: Some("   ".to_string()),
+            llm: AppLlmConfigUpdate {
+                providers: vec![AppLlmProviderConfigUpdate {
+                    id: "openai-compatible".to_string(),
+                    base_url: Some(" http://127.0.0.1:1234/v1/ ".to_string()),
+                    api_key: None,
+                    clear_api_key: false,
+                }],
             },
         })
         .unwrap();
 
-        assert!(app.http_proxy().is_none());
+        let public = to_public_config(&config).unwrap();
+
+        assert_eq!(public.data.path, "/tmp/koharu-data");
+        assert_eq!(
+            public
+                .llm
+                .providers
+                .iter()
+                .find(|provider| provider.id == "openai-compatible")
+                .and_then(|provider| provider.base_url.as_deref()),
+            Some("http://127.0.0.1:1234/v1/")
+        );
     }
 
     #[test]
-    fn empty_paths_are_rejected() {
-        let error = from_bootstrap_config(BootstrapConfig {
-            runtime: BootstrapPathConfig {
-                path: "   ".to_string(),
-            },
-            models: BootstrapPathConfig {
-                path: ".".to_string(),
+    fn public_update_requires_absolute_data_path() {
+        let error = from_public_update(AppConfigUpdate {
+            data: AppDataConfigUpdate {
+                path: "relative\\koharu-data".to_string(),
             },
-            http: BootstrapHttpConfig::default(),
+            llm: AppLlmConfigUpdate::default(),
         })
-        .expect_err("empty runtime path must be rejected");
+        .unwrap_err();
 
-        assert!(error.to_string().contains("runtime path is required"));
+        assert!(error.to_string().contains("absolute"));
     }
 
     #[test]
-    fn defaults_use_runtime_owned_paths() {
-        let config = AppConfig::default();
-        assert!(
-            config.runtime.path.is_absolute() || config.runtime.path == Path::new("").to_path_buf()
-        );
-        assert!(
-            config.models.path.is_absolute() || config.models.path == Path::new("").to_path_buf()
-        );
+    fn move_app_data_moves_managed_directories() {
+        let tempdir = tempfile::tempdir().unwrap();
+        let current = tempdir.path().join("old");
+        let next = tempdir.path().join("new");
+        fs::create_dir_all(current.join("pages")).unwrap();
+        fs::create_dir_all(current.join("runtime")).unwrap();
+        fs::write(current.join("pages").join("doc.json"), b"{}").unwrap();
+        fs::write(current.join("runtime").join("pkg.bin"), b"runtime").unwrap();
+
+        let current_config = StoredConfig {
+            data: super::StoredDataConfig {
+                path: Utf8PathBuf::from_path_buf(current.clone()).unwrap(),
+            },
+            ..StoredConfig::default()
+        };
+        let next_config = StoredConfig {
+            data: super::StoredDataConfig {
+                path: Utf8PathBuf::from_path_buf(next.clone()).unwrap(),
+            },
+            ..StoredConfig::default()
+        };
+
+        let moved = move_app_data_if_needed(&current_config, &next_config).unwrap();
+
+        assert!(moved);
+        assert!(next.join("pages").join("doc.json").exists());
+        assert!(next.join("runtime").join("pkg.bin").exists());
+        assert!(!current.join("pages").exists());
+        assert!(!current.join("runtime").exists());
     }
+
     #[test]
-    fn config_path_uses_home_dir_layout() {
-        let path = super::config_path().unwrap();
-        assert_eq!(
-            path.file_name().and_then(|name| name.to_str()),
-            Some("config.toml")
-        );
-        assert!(path.to_string_lossy().contains(".koharu"));
-        let _ = env::var_os("HOME");
+    fn config_path_uses_appdata_layout() {
+        let path = config_path().unwrap();
+        assert_eq!(path.file_name(), Some("config.toml"));
+        assert!(path.as_str().contains("Koharu"));
     }
 }

koharu-app/src/{ops/edit.rs → edit.rs}

@@ -1,144 +1,14 @@
 use image::DynamicImage;
 use image::GenericImageView;
 use imageproc::distance_transform::Norm;
-use koharu_core::commands::{
-    AddTextBlockPayload, InpaintPartialPayload, MaskMorphPayload, RemoveTextBlockPayload,
-    UpdateBrushLayerPayload, UpdateInpaintMaskPayload, UpdateTextBlockPayload,
-    UpdateTextBlocksPayload,
-};
+use koharu_core::Region;
 use koharu_core::parse::parse_hex_color;
 use koharu_core::views::{TextBlockInfo, to_block_info};
 use koharu_core::{SerializableDynamicImage, TextBlock, TextStyle};
 use tracing::instrument;
 
-use crate::{
-    AppResources,
-    state_tx::{self, ChangedField},
-};
-
-use super::utils::{InpaintRegionExt, blank_rgba};
-
-const MATCH_GEOMETRY_EPS: f32 = 0.01;
-const MATCH_NEAR_GEOMETRY_DELTA: f32 = 4.0;
-const MATCH_TEXT_GEOMETRY_DELTA: f32 = 64.0;
-
-fn geometry_delta(a: &TextBlock, b: &TextBlock) -> f32 {
-    (a.x - b.x).abs() + (a.y - b.y).abs() + (a.width - b.width).abs() + (a.height - b.height).abs()
-}
-
-fn geometry_changed(a: &TextBlock, b: &TextBlock) -> bool {
-    geometry_delta(a, b) > MATCH_GEOMETRY_EPS
-}
-
-fn size_changed(a: &TextBlock, b: &TextBlock) -> bool {
-    (a.width - b.width).abs() > MATCH_GEOMETRY_EPS
-        || (a.height - b.height).abs() > MATCH_GEOMETRY_EPS
-}
-
-fn geometry_overlaps(a: &TextBlock, b: &TextBlock) -> bool {
-    let ax0 = a.x;
-    let ay0 = a.y;
-    let ax1 = a.x + a.width;
-    let ay1 = a.y + a.height;
-    let bx0 = b.x;
-    let by0 = b.y;
-    let bx1 = b.x + b.width;
-    let by1 = b.y + b.height;
-
-    ax0 < bx1 && ay0 < by1 && ax1 > bx0 && ay1 > by0
-}
-
-fn has_stable_content_identity(a: &TextBlock, b: &TextBlock) -> bool {
-    let has_content =
-        a.text.is_some() || a.translation.is_some() || b.text.is_some() || b.translation.is_some();
-    has_content && a.text == b.text && a.translation == b.translation
-}
-
-fn seed_from_block(block: &TextBlock) -> Option<(f32, f32, f32, f32)> {
-    match (
-        block.layout_seed_x,
-        block.layout_seed_y,
-        block.layout_seed_width,
-        block.layout_seed_height,
-    ) {
-        (Some(x), Some(y), Some(width), Some(height))
-            if width.is_finite() && height.is_finite() && width > 0.0 && height > 0.0 =>
-        {
-            Some((x, y, width, height))
-        }
-        _ => None,
-    }
-}
-
-fn find_matching_previous(
-    current: &TextBlock,
-    current_index: usize,
-    previous: &[TextBlock],
-    used_previous: &[bool],
-) -> Option<usize> {
-    if current_index < previous.len() && !used_previous[current_index] {
-        let indexed = &previous[current_index];
-        let delta = geometry_delta(current, indexed);
-        if delta <= MATCH_NEAR_GEOMETRY_DELTA
-            || geometry_overlaps(current, indexed)
-            || has_stable_content_identity(current, indexed)
-        {
-            return Some(current_index);
-        }
-    }
-
-    let mut best_idx = None;
-    let mut best_delta = f32::INFINITY;
-
-    for (idx, prev) in previous.iter().enumerate() {
-        if used_previous[idx] {
-            continue;
-        }
-        let delta = geometry_delta(current, prev);
-        if delta < best_delta {
-            best_idx = Some(idx);
-            best_delta = delta;
-        }
-    }
-
-    let candidate_idx = best_idx?;
-    let candidate = &previous[candidate_idx];
-    if best_delta <= MATCH_NEAR_GEOMETRY_DELTA {
-        return Some(candidate_idx);
-    }
-
-    if has_stable_content_identity(current, candidate) && best_delta <= MATCH_TEXT_GEOMETRY_DELTA {
-        return Some(candidate_idx);
-    }
-
-    None
-}
-
-fn rehydrate_runtime_text_block_state(current: &mut TextBlock, previous: Option<&TextBlock>) {
-    let Some(prev) = previous else {
-        current.lock_layout_box = false;
-        current.set_layout_seed(current.x, current.y, current.width, current.height);
-        return;
-    };
-
-    if current.id.trim().is_empty() {
-        current.id = prev.id.clone();
-    }
-
-    current.lock_layout_box = if size_changed(current, prev) {
-        true
-    } else {
-        prev.lock_layout_box
-    };
-
-    if geometry_changed(current, prev) {
-        current.set_layout_seed(current.x, current.y, current.width, current.height);
-    } else if let Some((x, y, width, height)) = seed_from_block(prev) {
-        current.set_layout_seed(x, y, width, height);
-    } else {
-        current.set_layout_seed(current.x, current.y, current.width, current.height);
-    }
-}
+use crate::AppResources;
+use crate::utils::{InpaintRegionExt, blank_rgba};
 
 fn block_bounds(block: &TextBlock) -> Option<(f32, f32, f32, f32)> {
     let bx0 = block.x.max(0.0);
@@ -210,219 +80,198 @@ fn paste_crop(stitched: &mut image::RgbaImage, patch: &image::RgbaImage, x0: u32
 
 pub async fn update_text_blocks(
     state: AppResources,
-    payload: UpdateTextBlocksPayload,
+    document_id: &str,
+    text_blocks: Vec<TextBlock>,
 ) -> anyhow::Result<()> {
-    state_tx::mutate_doc(
-        &state.state,
-        payload.index,
-        &[ChangedField::TextBlocks],
-        |document| {
-            let previous = std::mem::take(&mut document.text_blocks);
-            document.text_blocks = payload.text_blocks;
-
-            let mut used_previous = vec![false; previous.len()];
-            for (block_index, block) in document.text_blocks.iter_mut().enumerate() {
-                let matched_idx =
-                    find_matching_previous(block, block_index, &previous, &used_previous);
-                if let Some(idx) = matched_idx {
-                    used_previous[idx] = true;
-                    rehydrate_runtime_text_block_state(block, Some(&previous[idx]));
-                } else {
-                    rehydrate_runtime_text_block_state(block, None);
-                }
-            }
-            Ok(())
-        },
-    )
-    .await
+    let mut doc = state.cache.get(document_id).await?;
+    doc.text_blocks = text_blocks;
+    state.cache.put(&doc).await?;
+    Ok(())
+}
+
+pub struct UpdateTextBlockArgs {
+    pub text_block_index: usize,
+    pub translation: Option<String>,
+    pub x: Option<f32>,
+    pub y: Option<f32>,
+    pub width: Option<f32>,
+    pub height: Option<f32>,
+    pub font_families: Option<Vec<String>>,
+    pub font_size: Option<f32>,
+    pub color: Option<String>,
+    pub shader_effect: Option<String>,
 }
 
 pub async fn update_text_block(
     state: AppResources,
-    payload: UpdateTextBlockPayload,
+    document_id: &str,
+    args: UpdateTextBlockArgs,
 ) -> anyhow::Result<TextBlockInfo> {
-    state_tx::mutate_doc(
-        &state.state,
-        payload.index,
-        &[ChangedField::TextBlocks],
-        |document| {
-            let block = document
-                .text_blocks
-                .get_mut(payload.text_block_index)
-                .ok_or_else(|| {
-                    anyhow::anyhow!("Text block {} not found", payload.text_block_index)
-                })?;
-            let mut geometry_changed = false;
-
-            if let Some(translation) = payload.translation {
-                block.translation = Some(translation);
-            }
-            if let Some(x) = payload.x {
-                block.x = x;
-                geometry_changed = true;
-            }
-            if let Some(y) = payload.y {
-                block.y = y;
-                geometry_changed = true;
-            }
-            if let Some(width) = payload.width {
-                block.width = width;
-                geometry_changed = true;
-                block.lock_layout_box = true;
-            }
-            if let Some(height) = payload.height {
-                block.height = height;
-                geometry_changed = true;
-                block.lock_layout_box = true;
-            }
-            if geometry_changed {
-                block.set_layout_seed(block.x, block.y, block.width, block.height);
-            }
+    let mut doc = state.cache.get(document_id).await?;
 
-            if payload.font_families.is_some()
-                || payload.font_size.is_some()
-                || payload.color.is_some()
-                || payload.shader_effect.is_some()
-            {
-                let style = block.style.get_or_insert_with(|| TextStyle {
-                    font_families: Vec::new(),
-                    font_size: None,
-                    color: [0, 0, 0, 255],
-                    effect: None,
-                    stroke: None,
-                    text_align: None,
-                });
-
-                if let Some(families) = payload.font_families {
-                    style.font_families = families;
-                }
-                if let Some(font_size) = payload.font_size {
-                    style.font_size = Some(font_size);
-                }
-                if let Some(hex) = payload.color {
-                    style.color = parse_hex_color(&hex)?;
-                }
-                if let Some(effect) = payload.shader_effect {
-                    style.effect = Some(effect.parse()?);
-                }
-            }
+    let block = doc
+        .text_blocks
+        .get_mut(args.text_block_index)
+        .ok_or_else(|| anyhow::anyhow!("Text block {} not found", args.text_block_index))?;
+    let mut geometry_changed = false;
 
-            block.rendered = None;
-            block.rendered_direction = None;
-            Ok(to_block_info(payload.text_block_index, block))
-        },
-    )
-    .await
+    if let Some(translation) = args.translation {
+        block.translation = Some(translation);
+    }
+    if let Some(x) = args.x {
+        block.x = x;
+        geometry_changed = true;
+    }
+    if let Some(y) = args.y {
+        block.y = y;
+        geometry_changed = true;
+    }
+    if let Some(width) = args.width {
+        block.width = width;
+        geometry_changed = true;
+        block.lock_layout_box = true;
+    }
+    if let Some(height) = args.height {
+        block.height = height;
+        geometry_changed = true;
+        block.lock_layout_box = true;
+    }
+    if geometry_changed {
+        block.set_layout_seed(block.x, block.y, block.width, block.height);
+    }
+
+    if args.font_families.is_some()
+        || args.font_size.is_some()
+        || args.color.is_some()
+        || args.shader_effect.is_some()
+    {
+        let style = block.style.get_or_insert_with(|| TextStyle {
+            font_families: Vec::new(),
+            font_size: None,
+            color: [0, 0, 0, 255],
+            effect: None,
+            stroke: None,
+            text_align: None,
+        });
+
+        if let Some(families) = args.font_families {
+            style.font_families = families;
+        }
+        if let Some(font_size) = args.font_size {
+            style.font_size = Some(font_size);
+        }
+        if let Some(hex) = args.color {
+            style.color = parse_hex_color(&hex)?;
+        }
+        if let Some(effect) = args.shader_effect {
+            style.effect = Some(effect.parse()?);
+        }
+    }
+
+    block.rendered = None;
+    block.rendered_direction = None;
+    let info = to_block_info(args.text_block_index, block);
+    state.cache.put(&doc).await?;
+    Ok(info)
 }
 
 pub async fn add_text_block(
     state: AppResources,
-    payload: AddTextBlockPayload,
+    document_id: &str,
+    x: f32,
+    y: f32,
+    width: f32,
+    height: f32,
 ) -> anyhow::Result<usize> {
-    state_tx::mutate_doc(
-        &state.state,
-        payload.index,
-        &[ChangedField::TextBlocks],
-        |document| {
-            let mut block = TextBlock {
-                x: payload.x,
-                y: payload.y,
-                width: payload.width,
-                height: payload.height,
-                confidence: 1.0,
-                ..Default::default()
-            };
-            block.set_layout_seed(block.x, block.y, block.width, block.height);
-            document.text_blocks.push(block);
-            Ok(document.text_blocks.len() - 1)
-        },
-    )
-    .await
+    let mut doc = state.cache.get(document_id).await?;
+
+    let mut block = TextBlock {
+        x,
+        y,
+        width,
+        height,
+        confidence: 1.0,
+        ..Default::default()
+    };
+    block.set_layout_seed(block.x, block.y, block.width, block.height);
+    doc.text_blocks.push(block);
+    let count = doc.text_blocks.len() - 1;
+    state.cache.put(&doc).await?;
+    Ok(count)
 }
 
 pub async fn remove_text_block(
     state: AppResources,
-    payload: RemoveTextBlockPayload,
+    document_id: &str,
+    text_block_index: usize,
 ) -> anyhow::Result<usize> {
-    state_tx::mutate_doc(
-        &state.state,
-        payload.index,
-        &[ChangedField::TextBlocks],
-        |document| {
-            if payload.text_block_index >= document.text_blocks.len() {
-                anyhow::bail!("Text block {} not found", payload.text_block_index);
-            }
-            document.text_blocks.remove(payload.text_block_index);
-            Ok(document.text_blocks.len())
-        },
-    )
-    .await
+    let mut doc = state.cache.get(document_id).await?;
+
+    if text_block_index >= doc.text_blocks.len() {
+        anyhow::bail!("Text block {} not found", text_block_index);
+    }
+    doc.text_blocks.remove(text_block_index);
+    let count = doc.text_blocks.len();
+    state.cache.put(&doc).await?;
+    Ok(count)
 }
 
-pub async fn dilate_mask(state: AppResources, payload: MaskMorphPayload) -> anyhow::Result<()> {
-    if payload.radius == 0 || payload.radius > 50 {
+pub async fn dilate_mask(state: AppResources, document_id: &str, radius: u8) -> anyhow::Result<()> {
+    if radius == 0 || radius > 50 {
         anyhow::bail!("Radius must be 1-50");
     }
 
-    state_tx::mutate_doc(
-        &state.state,
-        payload.index,
-        &[ChangedField::Segment],
-        |document| {
-            let segment = document
-                .segment
-                .as_ref()
-                .ok_or_else(|| anyhow::anyhow!("No segment mask. Run detect first."))?;
-
-            let gray = segment.to_luma8();
-            let dilated = imageproc::morphology::dilate(&gray, Norm::LInf, payload.radius);
-            document.segment = Some(SerializableDynamicImage(DynamicImage::ImageLuma8(dilated)));
-            Ok(())
-        },
-    )
-    .await
+    let mut doc = state.cache.get(document_id).await?;
+
+    let segment = doc
+        .segment
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("No segment mask. Run detect first."))?;
+
+    let gray = segment.to_luma8();
+    let dilated = imageproc::morphology::dilate(&gray, Norm::LInf, radius);
+    doc.segment = Some(SerializableDynamicImage(DynamicImage::ImageLuma8(dilated)));
+    state.cache.put(&doc).await?;
+    Ok(())
 }
 
-pub async fn erode_mask(state: AppResources, payload: MaskMorphPayload) -> anyhow::Result<()> {
-    if payload.radius == 0 || payload.radius > 50 {
+pub async fn erode_mask(state: AppResources, document_id: &str, radius: u8) -> anyhow::Result<()> {
+    if radius == 0 || radius > 50 {
         anyhow::bail!("Radius must be 1-50");
     }
 
-    state_tx::mutate_doc(
-        &state.state,
-        payload.index,
-        &[ChangedField::Segment],
-        |document| {
-            let segment = document
-                .segment
-                .as_ref()
-                .ok_or_else(|| anyhow::anyhow!("No segment mask. Run detect first."))?;
-
-            let gray = segment.to_luma8();
-            let eroded = imageproc::morphology::erode(&gray, Norm::LInf, payload.radius);
-            document.segment = Some(SerializableDynamicImage(DynamicImage::ImageLuma8(eroded)));
-            Ok(())
-        },
-    )
-    .await
+    let mut doc = state.cache.get(document_id).await?;
+
+    let segment = doc
+        .segment
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("No segment mask. Run detect first."))?;
+
+    let gray = segment.to_luma8();
+    let eroded = imageproc::morphology::erode(&gray, Norm::LInf, radius);
+    doc.segment = Some(SerializableDynamicImage(DynamicImage::ImageLuma8(eroded)));
+    state.cache.put(&doc).await?;
+    Ok(())
 }
 
 pub async fn update_inpaint_mask(
     state: AppResources,
-    payload: UpdateInpaintMaskPayload,
+    document_id: &str,
+    mask: &[u8],
+    region: Option<Region>,
 ) -> anyhow::Result<()> {
-    let snapshot = state_tx::read_doc(&state.state, payload.index).await?;
+    let mut doc = state.cache.get(document_id).await?;
 
-    let update_image = image::load_from_memory(&payload.mask)?;
-    let (doc_width, doc_height) = (snapshot.width, snapshot.height);
+    let update_image = image::load_from_memory(mask)?;
+    let (doc_width, doc_height) = (doc.width, doc.height);
 
-    let mut base_mask = snapshot
+    let mut base_mask = doc
         .segment
         .clone()
         .unwrap_or_else(|| blank_rgba(doc_width, doc_height, image::Rgba([0, 0, 0, 255])))
         .to_rgba8();
 
-    match payload.region {
+    match region {
         Some(region) => {
             let (patch_width, patch_height) = update_image.dimensions();
             if patch_width != region.width || patch_height != region.height {
@@ -466,43 +315,39 @@ pub async fn update_inpaint_mask(
         }
     }
 
-    let mut updated = snapshot;
-    updated.segment = Some(image::DynamicImage::ImageRgba8(base_mask).into());
-    state_tx::update_doc(
-        &state.state,
-        payload.index,
-        updated,
-        &[ChangedField::Segment],
-    )
-    .await
+    doc.segment = Some(image::DynamicImage::ImageRgba8(base_mask).into());
+    state.cache.put(&doc).await?;
+    Ok(())
 }
 
 pub async fn update_brush_layer(
     state: AppResources,
-    payload: UpdateBrushLayerPayload,
+    document_id: &str,
+    patch: &[u8],
+    brush_region: Region,
 ) -> anyhow::Result<()> {
-    let snapshot = state_tx::read_doc(&state.state, payload.index).await?;
+    let mut doc = state.cache.get(document_id).await?;
 
-    let (img_width, img_height) = (snapshot.width, snapshot.height);
-    let Some((x0, y0, width, height)) = payload.region.clamp(img_width, img_height) else {
+    let (img_width, img_height) = (doc.width, doc.height);
+    let Some((x0, y0, width, height)) = brush_region.clamp(img_width, img_height) else {
         return Ok(());
     };
 
-    let patch_image = image::load_from_memory(&payload.patch)?;
+    let patch_image = image::load_from_memory(patch)?;
     let (patch_width, patch_height) = patch_image.dimensions();
 
-    if patch_width != payload.region.width || patch_height != payload.region.height {
+    if patch_width != brush_region.width || patch_height != brush_region.height {
         anyhow::bail!(
             "Brush patch size mismatch: expected {}x{}, got {}x{}",
-            payload.region.width,
-            payload.region.height,
+            brush_region.width,
+            brush_region.height,
             patch_width,
             patch_height
         );
     }
 
     let brush_rgba = patch_image.to_rgba8();
-    let mut brush_layer = snapshot
+    let mut brush_layer = doc
         .brush_layer
         .clone()
         .unwrap_or_else(|| blank_rgba(img_width, img_height, image::Rgba([0, 0, 0, 0])))
@@ -514,46 +359,38 @@ pub async fn update_brush_layer(
         }
     }
 
-    let mut updated = snapshot;
-    updated.brush_layer = Some(image::DynamicImage::ImageRgba8(brush_layer).into());
-
-    state_tx::update_doc(
-        &state.state,
-        payload.index,
-        updated,
-        &[ChangedField::BrushLayer],
-    )
-    .await
+    doc.brush_layer = Some(image::DynamicImage::ImageRgba8(brush_layer).into());
+    state.cache.put(&doc).await?;
+    Ok(())
 }
 
 #[instrument(level = "info", skip_all)]
 pub async fn inpaint_partial(
     state: AppResources,
-    payload: InpaintPartialPayload,
+    document_id: &str,
+    inpaint_region: Region,
 ) -> anyhow::Result<()> {
-    let snapshot = state_tx::read_doc(&state.state, payload.index).await?;
+    let mut doc = state.cache.get(document_id).await?;
 
-    let mask_image = snapshot
+    let mask_image = doc
         .segment
         .as_ref()
         .ok_or_else(|| anyhow::anyhow!("Segment image not found"))?;
 
-    if payload.region.width == 0 || payload.region.height == 0 {
+    if inpaint_region.width == 0 || inpaint_region.height == 0 {
         return Ok(());
     }
 
-    let (img_width, img_height) = (snapshot.width, snapshot.height);
-    let x0 = payload.region.x.min(img_width.saturating_sub(1));
-    let y0 = payload.region.y.min(img_height.saturating_sub(1));
-    let x1 = payload
-        .region
+    let (img_width, img_height) = (doc.width, doc.height);
+    let x0 = inpaint_region.x.min(img_width.saturating_sub(1));
+    let y0 = inpaint_region.y.min(img_height.saturating_sub(1));
+    let x1 = inpaint_region
         .x
-        .saturating_add(payload.region.width)
+        .saturating_add(inpaint_region.width)
         .min(img_width);
-    let y1 = payload
-        .region
+    let y1 = inpaint_region
         .y
-        .saturating_add(payload.region.height)
+        .saturating_add(inpaint_region.height)
         .min(img_height);
     let crop_width = x1.saturating_sub(x0);
     let crop_height = y1.saturating_sub(y0);
@@ -563,13 +400,12 @@ pub async fn inpaint_partial(
     }
 
     let localized_blocks =
-        localize_inpaint_text_blocks(&snapshot.text_blocks, x0, y0, crop_width, crop_height);
+        localize_inpaint_text_blocks(&doc.text_blocks, x0, y0, crop_width, crop_height);
     if localized_blocks.is_empty() {
         return Ok(());
     }
 
-    let image_crop =
-        SerializableDynamicImage(snapshot.image.crop_imm(x0, y0, crop_width, crop_height));
+    let image_crop = SerializableDynamicImage(doc.image.crop_imm(x0, y0, crop_width, crop_height));
     let mask_crop = SerializableDynamicImage(mask_image.crop_imm(x0, y0, crop_width, crop_height));
 
     let inpainted_crop = state
@@ -577,85 +413,22 @@ pub async fn inpaint_partial(
         .inpaint_raw(&image_crop, &mask_crop, Some(&localized_blocks))
         .await?;
 
-    let mut stitched = snapshot
-        .inpainted
-        .as_ref()
-        .unwrap_or(&snapshot.image)
-        .to_rgba8();
+    let mut stitched = doc.inpainted.as_ref().unwrap_or(&doc.image).to_rgba8();
 
     let patch = inpainted_crop.to_rgba8();
     paste_crop(&mut stitched, &patch, x0, y0);
 
-    let mut updated = snapshot;
-    updated.inpainted = Some(image::DynamicImage::ImageRgba8(stitched).into());
-
-    state_tx::update_doc(
-        &state.state,
-        payload.index,
-        updated,
-        &[ChangedField::Inpainted],
-    )
-    .await
+    doc.inpainted = Some(image::DynamicImage::ImageRgba8(stitched).into());
+    state.cache.put(&doc).await?;
+    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{
-        find_matching_previous, localize_inpaint_text_blocks, paste_crop,
-        rehydrate_runtime_text_block_state,
-    };
+    use super::{localize_inpaint_text_blocks, paste_crop};
     use image::{Rgba, RgbaImage};
     use koharu_core::TextBlock;
 
-    #[test]
-    fn resized_block_locks_layout_box() {
-        let previous = TextBlock {
-            x: 10.0,
-            y: 20.0,
-            width: 100.0,
-            height: 80.0,
-            ..Default::default()
-        };
-        let mut current = TextBlock {
-            x: 10.0,
-            y: 20.0,
-            width: 72.0,
-            height: 80.0,
-            ..Default::default()
-        };
-
-        rehydrate_runtime_text_block_state(&mut current, Some(&previous));
-
-        assert!(current.lock_layout_box);
-        assert_eq!(current.seed_layout_box(), (10.0, 20.0, 72.0, 80.0));
-    }
-
-    #[test]
-    fn unchanged_block_preserves_layout_box_lock_and_seed() {
-        let mut previous = TextBlock {
-            x: 10.0,
-            y: 20.0,
-            width: 100.0,
-            height: 80.0,
-            lock_layout_box: true,
-            ..Default::default()
-        };
-        previous.set_layout_seed(5.0, 6.0, 70.0, 60.0);
-
-        let mut current = TextBlock {
-            x: 10.0,
-            y: 20.0,
-            width: 100.0,
-            height: 80.0,
-            ..Default::default()
-        };
-
-        rehydrate_runtime_text_block_state(&mut current, Some(&previous));
-
-        assert!(current.lock_layout_box);
-        assert_eq!(current.seed_layout_box(), (5.0, 6.0, 70.0, 60.0));
-    }
-
     #[test]
     fn partial_inpaint_blocks_are_localized_to_crop() {
         let block = TextBlock {
@@ -709,69 +482,4 @@ mod tests {
         assert_eq!(stitched.get_pixel(4, 4).0, [255, 0, 0, 255]);
         assert_eq!(stitched.get_pixel(1, 1).0, [0, 0, 0, 255]);
     }
-
-    #[test]
-    fn matching_previous_prefers_same_index_for_large_manual_resize() {
-        let previous = vec![
-            TextBlock {
-                x: 10.0,
-                y: 10.0,
-                width: 40.0,
-                height: 20.0,
-                translation: Some("HELLO".to_string()),
-                ..Default::default()
-            },
-            TextBlock {
-                x: 100.0,
-                y: 10.0,
-                width: 40.0,
-                height: 20.0,
-                translation: Some("WORLD".to_string()),
-                ..Default::default()
-            },
-        ];
-
-        let current = TextBlock {
-            x: 10.0,
-            y: 10.0,
-            width: 140.0,
-            height: 80.0,
-            translation: Some("HELLO".to_string()),
-            ..Default::default()
-        };
-
-        let matched = find_matching_previous(&current, 0, &previous, &[false, false]);
-        assert_eq!(matched, Some(0));
-    }
-
-    #[test]
-    fn non_overlapping_same_index_without_identity_does_not_force_match() {
-        let previous = vec![
-            TextBlock {
-                x: 10.0,
-                y: 10.0,
-                width: 20.0,
-                height: 20.0,
-                ..Default::default()
-            },
-            TextBlock {
-                x: 80.0,
-                y: 10.0,
-                width: 20.0,
-                height: 20.0,
-                ..Default::default()
-            },
-        ];
-
-        let current = TextBlock {
-            x: 82.0,
-            y: 12.0,
-            width: 20.0,
-            height: 20.0,
-            ..Default::default()
-        };
-
-        let matched = find_matching_previous(&current, 0, &previous, &[false, false]);
-        assert_eq!(matched, Some(1));
-    }
 }

koharu-app/src/{ops/core.rs → io.rs}

@@ -2,14 +2,12 @@ use std::path::{Path, PathBuf};
 
 use image::ImageFormat;
 use koharu_core::commands::{
-    DeviceInfo, FileResult, IndexPayload, OpenDocumentsPayload, OpenExternalPayload,
-    ThumbnailResult,
+    DeviceInfo, FileResult, OpenDocumentsPayload, OpenExternalPayload, ThumbnailResult,
 };
 use rfd::FileDialog;
 
-use crate::{AppResources, state_tx};
-
-use super::utils::{encode_image, load_documents, mime_from_ext};
+use crate::AppResources;
+use crate::utils::{encode_image, mime_from_ext};
 
 fn next_available_path(output_dir: &Path, stem: &str, ext: &str) -> PathBuf {
     let mut candidate = output_dir.join(format!("{stem}.{ext}"));
@@ -25,15 +23,6 @@ async fn pick_output_dir() -> anyhow::Result<Option<PathBuf>> {
     Ok(tokio::task::spawn_blocking(|| FileDialog::new().pick_folder()).await?)
 }
 
-fn document_ext(document: &koharu_core::Document) -> String {
-    document
-        .path
-        .extension()
-        .and_then(|value| value.to_str())
-        .unwrap_or("jpg")
-        .to_string()
-}
-
 fn export_documents_matching(
     documents: &[koharu_core::Document],
     output_dir: &Path,
@@ -48,7 +37,12 @@ fn export_documents_matching(
             continue;
         };
 
-        let ext = document_ext(document);
+        let ext = document
+            .path
+            .extension()
+            .and_then(|value| value.to_str())
+            .unwrap_or("jpg")
+            .to_string();
         let output_path =
             next_available_path(output_dir, &format!("{}_{}", document.name, suffix), &ext);
         let bytes = encode_image(image, &ext)?;
@@ -83,22 +77,21 @@ pub async fn open_external(
 }
 
 pub async fn get_documents(state: AppResources) -> anyhow::Result<usize> {
-    let guard = state.state.read().await;
-    Ok(guard.documents.len())
+    Ok(state.cache.list_documents()?.len())
 }
 
 pub async fn get_document(
     state: AppResources,
-    payload: IndexPayload,
+    document_id: &str,
 ) -> anyhow::Result<koharu_core::Document> {
-    state_tx::read_doc(&state.state, payload.index).await
+    state.cache.get(document_id).await
 }
 
 pub async fn get_thumbnail(
     state: AppResources,
-    payload: IndexPayload,
+    document_id: &str,
 ) -> anyhow::Result<ThumbnailResult> {
-    let doc = state_tx::read_doc(&state.state, payload.index).await?;
+    let doc = state.cache.get(document_id).await?;
 
     let source = doc.rendered.as_ref().unwrap_or(&doc.image);
     let thumbnail = source.thumbnail(200, 200);
@@ -116,43 +109,33 @@ pub async fn open_documents(
     state: AppResources,
     payload: OpenDocumentsPayload,
 ) -> anyhow::Result<usize> {
-    let inputs: Vec<(PathBuf, Vec<u8>)> = payload
-        .files
-        .into_iter()
-        .map(|f| (PathBuf::from(f.name), f.data))
-        .collect();
-
-    if inputs.is_empty() {
+    if payload.files.is_empty() {
         anyhow::bail!("No files uploaded");
     }
 
-    let docs = load_documents(inputs)?;
-    state_tx::replace_docs(&state.state, docs).await
+    let manifests = state.cache.import_files(payload.files)?;
+    let count = manifests.len();
+    state.cache.replace_manifests(&manifests).await?;
+    Ok(count)
 }
 
 pub async fn add_documents(
     state: AppResources,
     payload: OpenDocumentsPayload,
 ) -> anyhow::Result<usize> {
-    let inputs: Vec<(PathBuf, Vec<u8>)> = payload
-        .files
-        .into_iter()
-        .map(|f| (PathBuf::from(f.name), f.data))
-        .collect();
-
-    if inputs.is_empty() {
+    if payload.files.is_empty() {
         anyhow::bail!("No files uploaded");
     }
 
-    let docs = load_documents(inputs)?;
-    state_tx::append_docs(&state.state, docs).await
+    let manifests = state.cache.import_files(payload.files)?;
+    for manifest in &manifests {
+        state.cache.save_manifest(manifest)?;
+    }
+    Ok(state.cache.list_documents()?.len())
 }
 
-pub async fn export_document(
-    state: AppResources,
-    payload: IndexPayload,
-) -> anyhow::Result<FileResult> {
-    let document = state_tx::read_doc(&state.state, payload.index).await?;
+pub async fn export_document(state: AppResources, document_id: &str) -> anyhow::Result<FileResult> {
+    let document = state.cache.get(document_id).await?;
 
     let ext = document
         .path
@@ -182,9 +165,18 @@ pub async fn export_all_inpainted(state: AppResources) -> anyhow::Result<usize>
         return Ok(0);
     };
 
-    let guard = state.state.read().await;
+    let page_ids: Vec<String> = state
+        .cache
+        .list_documents()?
+        .into_iter()
+        .map(|e| e.id)
+        .collect();
+    let mut documents = Vec::new();
+    for id in &page_ids {
+        documents.push(state.cache.get(id).await?);
+    }
     export_documents_matching(
-        &guard.documents,
+        &documents,
         &output_dir,
         "inpainted",
         "No inpainted images found to export",
@@ -197,9 +189,18 @@ pub async fn export_all_rendered(state: AppResources) -> anyhow::Result<usize> {
         return Ok(0);
     };
 
-    let guard = state.state.read().await;
+    let page_ids: Vec<String> = state
+        .cache
+        .list_documents()?
+        .into_iter()
+        .map(|e| e.id)
+        .collect();
+    let mut documents = Vec::new();
+    for id in &page_ids {
+        documents.push(state.cache.get(id).await?);
+    }
     export_documents_matching(
-        &guard.documents,
+        &documents,
         &output_dir,
         "rendered",
         "No rendered images found to export",

koharu-app/src/lib.rs

@@ -1,23 +1,27 @@
+pub mod blob_store;
 pub mod config;
+pub mod edit;
+pub mod io;
 pub mod llm;
+pub mod manifest;
 pub mod ml;
-pub mod operations;
-pub mod ops;
+pub mod page_cache;
 pub mod pipeline;
 pub mod renderer;
-pub mod state_tx;
+pub mod utils;
 
 use std::sync::Arc;
 
-use koharu_core::AppState;
 use koharu_ml::Device;
 use koharu_runtime::RuntimeManager;
 use tokio::sync::RwLock;
 
+use crate::page_cache::PageCache;
+
 #[derive(Clone)]
 pub struct AppResources {
     pub runtime: RuntimeManager,
-    pub state: AppState,
+    pub cache: PageCache,
     pub ml: Arc<ml::Model>,
     pub llm: Arc<llm::Model>,
     pub renderer: Arc<renderer::Renderer>,

koharu-app/src/llm.rs

@@ -1,15 +1,28 @@
+use std::str::FromStr;
 use std::sync::Arc;
 
-use serde::Serialize;
+use koharu_llm::providers::{
+    AnyProvider, ProviderCatalogModels, ProviderConfig, all_provider_descriptors, build_provider,
+    discover_models, get_saved_api_key,
+};
 use tokio::sync::{RwLock, broadcast};
+use tracing::instrument;
 
-use koharu_core::{Document, LlmState, LlmStateStatus, TextBlock};
+use koharu_core::{
+    Document, LlmCatalog, LlmCatalogModel, LlmGenerationOptions, LlmLoadRequest,
+    LlmProviderCatalog, LlmProviderCatalogStatus, LlmState, LlmStateStatus, LlmTarget,
+    LlmTargetKind, TextBlock,
+};
 use koharu_runtime::RuntimeManager;
 
 use koharu_llm::{
     GenerateOptions, Language, Llm, ModelId, language::tags as language_tags,
     safe::llama_backend::LlamaBackend, supported_locales,
 };
+use strum::IntoEnumIterator;
+
+use crate::AppResources;
+use crate::config as app_config;
 
 pub use koharu_llm::prefetch;
 
@@ -26,50 +39,25 @@ struct BlockEndTag {
     len: usize,
 }
 
-#[derive(Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ModelInfo {
-    pub id: String,
-    pub languages: Vec<String>,
-    pub source: &'static str,
-}
-
-impl ModelInfo {
-    pub fn new(id: ModelId) -> Self {
-        let languages = id.languages();
-        Self {
-            id: id.to_string(),
-            languages: language_tags(&languages),
-            source: "local",
-        }
-    }
-
-    pub fn api(provider_id: &'static str, model_id: &str) -> Self {
-        Self {
-            id: format!("{provider_id}:{model_id}"),
-            languages: supported_locales(),
-            source: provider_id,
-        }
-    }
-}
-
 #[allow(clippy::large_enum_variant)]
 #[derive(strum::Display)]
 pub enum State {
     #[strum(serialize = "empty")]
     Empty,
     #[strum(serialize = "loading")]
-    Loading { model_id: String, source: String },
+    Loading { target: LlmTarget },
     #[strum(serialize = "ready")]
-    Ready(Llm),
+    ReadyLocal(Llm),
     #[strum(serialize = "ready")]
-    ApiReady {
-        provider: Box<dyn koharu_llm::providers::AnyProvider>,
-        provider_id: String,
-        model: String,
+    ReadyProvider {
+        target: LlmTarget,
+        provider: Box<dyn AnyProvider>,
     },
     #[strum(serialize = "failed")]
-    Failed(String),
+    Failed {
+        target: Option<LlmTarget>,
+        error: String,
+    },
 }
 
 pub struct Model {
@@ -85,6 +73,58 @@ pub trait Translatable {
     fn set_translation(&mut self, translation: String) -> anyhow::Result<()>;
 }
 
+fn local_target(id: ModelId) -> LlmTarget {
+    LlmTarget {
+        kind: LlmTargetKind::Local,
+        model_id: id.to_string(),
+        provider_id: None,
+    }
+}
+
+fn provider_target(provider_id: &str, model_id: &str) -> LlmTarget {
+    LlmTarget {
+        kind: LlmTargetKind::Provider,
+        model_id: model_id.to_string(),
+        provider_id: Some(provider_id.to_string()),
+    }
+}
+
+fn validate_target(target: &LlmTarget) -> anyhow::Result<()> {
+    match target.kind {
+        LlmTargetKind::Local => {
+            anyhow::ensure!(
+                target.provider_id.is_none(),
+                "local targets must not include provider_id"
+            );
+        }
+        LlmTargetKind::Provider => {
+            anyhow::ensure!(
+                target
+                    .provider_id
+                    .as_deref()
+                    .is_some_and(|value| !value.trim().is_empty()),
+                "provider targets require provider_id"
+            );
+        }
+    }
+
+    anyhow::ensure!(
+        !target.model_id.trim().is_empty(),
+        "target model_id is required"
+    );
+    Ok(())
+}
+
+fn state_target(state: &State) -> Option<LlmTarget> {
+    match state {
+        State::Empty => None,
+        State::Loading { target } => Some(target.clone()),
+        State::ReadyLocal(llm) => Some(local_target(llm.id())),
+        State::ReadyProvider { target, .. } => Some(target.clone()),
+        State::Failed { target, .. } => target.clone(),
+    }
+}
+
 fn escape_block_text(text: &str) -> String {
     text.replace('&', "&amp;")
         .replace('<', "&lt;")
@@ -453,28 +493,22 @@ impl Model {
         self.cpu
     }
 
-    pub async fn load_api(
+    pub async fn load_provider(
         &self,
-        provider_id: &str,
-        model_id: &str,
-        config: koharu_llm::providers::ProviderConfig,
+        target: LlmTarget,
+        provider: Box<dyn AnyProvider>,
     ) -> anyhow::Result<()> {
-        let provider = koharu_llm::providers::build_provider(provider_id, config)?;
-        *self.state.write().await = State::ApiReady {
-            provider,
-            provider_id: provider_id.to_string(),
-            model: model_id.to_string(),
-        };
+        *self.state.write().await = State::ReadyProvider { target, provider };
         self.emit_state().await;
         Ok(())
     }
 
-    pub async fn load(&self, id: ModelId) {
+    pub async fn load_local(&self, id: ModelId) {
+        let target = local_target(id);
         {
             let mut guard = self.state.write().await;
             *guard = State::Loading {
-                model_id: id.to_string(),
-                source: "local".to_string(),
+                target: target.clone(),
             };
         }
         self.emit_state().await;
@@ -489,12 +523,15 @@ impl Model {
             match res {
                 Ok(llm) => {
                     let mut guard = state_cloned.write().await;
-                    *guard = State::Ready(llm);
+                    *guard = State::ReadyLocal(llm);
                 }
                 Err(e) => {
                     tracing::error!("LLM load join error: {e}");
                     let mut guard = state_cloned.write().await;
-                    *guard = State::Failed(format!("join error: {e}"));
+                    *guard = State::Failed {
+                        target: Some(target),
+                        error: format!("join error: {e}"),
+                    };
                 }
             }
             let snapshot = {
@@ -521,10 +558,15 @@ impl Model {
     pub async fn ready(&self) -> bool {
         matches!(
             *self.state.read().await,
-            State::Ready(_) | State::ApiReady { .. }
+            State::ReadyLocal(_) | State::ReadyProvider { .. }
         )
     }
 
+    pub async fn current_target(&self) -> Option<LlmTarget> {
+        let guard = self.state.read().await;
+        state_target(&guard)
+    }
+
     pub fn subscribe(&self) -> broadcast::Receiver<LlmState> {
         self.state_tx.subscribe()
     }
@@ -553,17 +595,16 @@ impl Model {
         }
         let mut guard = self.state.write().await;
         let translation = match &mut *guard {
-            State::Ready(llm) => {
+            State::ReadyLocal(llm) => {
                 llm.generate(&source, &GenerateOptions::default(), target_language)
             }
-            State::ApiReady {
-                provider, model, ..
-            } => {
-                let model = model.clone();
-                provider.translate(&source, target_language, &model).await
+            State::ReadyProvider { target, provider } => {
+                provider
+                    .translate(&source, target_language, &target.model_id)
+                    .await
             }
             State::Loading { .. } => Err(anyhow::anyhow!("Model is still loading")),
-            State::Failed(e) => Err(anyhow::anyhow!("Model failed to load: {e}")),
+            State::Failed { error, .. } => Err(anyhow::anyhow!("Model failed to load: {error}")),
             State::Empty => Err(anyhow::anyhow!("No model is loaded")),
         }?;
         doc.set_translation(translation.trim().to_string())
@@ -574,39 +615,308 @@ fn snapshot_from_state(state: &State) -> LlmState {
     match state {
         State::Empty => LlmState {
             status: LlmStateStatus::Empty,
-            model_id: None,
-            source: None,
+            target: None,
             error: None,
         },
-        State::Loading { model_id, source } => LlmState {
+        State::Loading { target } => LlmState {
             status: LlmStateStatus::Loading,
-            model_id: Some(model_id.clone()),
-            source: Some(source.clone()),
+            target: Some(target.clone()),
             error: None,
         },
-        State::Ready(llm) => LlmState {
+        State::ReadyLocal(llm) => LlmState {
             status: LlmStateStatus::Ready,
-            model_id: Some(llm.id().to_string()),
-            source: Some("local".to_string()),
+            target: Some(local_target(llm.id())),
             error: None,
         },
-        State::ApiReady {
-            provider_id, model, ..
-        } => LlmState {
+        State::ReadyProvider { target, .. } => LlmState {
             status: LlmStateStatus::Ready,
-            model_id: Some(format!("{provider_id}:{model}")),
-            source: Some(provider_id.clone()),
+            target: Some(target.clone()),
             error: None,
         },
-        State::Failed(error) => LlmState {
+        State::Failed { target, error } => LlmState {
             status: LlmStateStatus::Failed,
-            model_id: None,
-            source: None,
+            target: target.clone(),
             error: Some(error.clone()),
         },
     }
 }
 
+// ---------------------------------------------------------------------------
+// Operations (merged from ops/llm.rs)
+// ---------------------------------------------------------------------------
+
+fn sorted_local_models(is_cpu: bool, language: Option<&str>) -> Vec<ModelId> {
+    let mut models: Vec<ModelId> = ModelId::iter().collect();
+    let cpu_factor = if is_cpu { 10 } else { 1 };
+    let lang = language.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 {
+        ModelId::VntlLlama3_8Bv2 => 100,
+        ModelId::Lfm2_350mEnjpMt => 200 / cpu_factor,
+        ModelId::SakuraGalTransl7Bv3_7 => 300 / zh_locale_factor,
+        ModelId::Sakura1_5bQwen2_5v1_0 => 400 / zh_locale_factor / cpu_factor,
+        ModelId::HunyuanMT7B => 500 / non_zh_en_locale_factor,
+    });
+    models
+}
+
+fn local_catalog_models(is_cpu: bool, language: Option<&str>) -> Vec<LlmCatalogModel> {
+    sorted_local_models(is_cpu, language)
+        .into_iter()
+        .map(|model| LlmCatalogModel {
+            target: local_target(model),
+            name: model.to_string(),
+            languages: language_tags(&model.languages()),
+        })
+        .collect()
+}
+
+async fn provider_catalog(state: &AppResources) -> anyhow::Result<Vec<LlmProviderCatalog>> {
+    let config = app_config::load()?;
+    let mut providers = Vec::new();
+
+    for descriptor in all_provider_descriptors() {
+        let stored = config.llm.providers.get(descriptor.id);
+        let base_url = stored.and_then(|provider| provider.base_url.clone());
+        let api_key = get_saved_api_key(descriptor.id)?;
+        let has_api_key = api_key
+            .as_deref()
+            .is_some_and(|value| !value.trim().is_empty());
+        let missing_required_config = (descriptor.requires_api_key && !has_api_key)
+            || (descriptor.requires_base_url
+                && base_url
+                    .as_deref()
+                    .is_none_or(|value| value.trim().is_empty()));
+
+        let (status, error, models) = if missing_required_config {
+            (
+                LlmProviderCatalogStatus::MissingConfiguration,
+                None,
+                static_provider_models(descriptor),
+            )
+        } else {
+            match &descriptor.models {
+                ProviderCatalogModels::Static(_) => (
+                    LlmProviderCatalogStatus::Ready,
+                    None,
+                    static_provider_models(descriptor),
+                ),
+                ProviderCatalogModels::Dynamic(_) => {
+                    let models = discover_models(
+                        descriptor.id,
+                        ProviderConfig {
+                            http_client: state.runtime.http_client(),
+                            api_key,
+                            base_url: base_url.clone(),
+                            temperature: None,
+                            max_tokens: None,
+                            custom_system_prompt: None,
+                        },
+                    )?
+                    .await;
+
+                    match models {
+                        Ok(models) => (
+                            LlmProviderCatalogStatus::Ready,
+                            None,
+                            models
+                                .into_iter()
+                                .map(|model| LlmCatalogModel {
+                                    target: provider_target(descriptor.id, &model.id),
+                                    name: model.name,
+                                    languages: supported_locales(),
+                                })
+                                .collect(),
+                        ),
+                        Err(error) => (
+                            LlmProviderCatalogStatus::DiscoveryFailed,
+                            Some(error.to_string()),
+                            Vec::new(),
+                        ),
+                    }
+                }
+            }
+        };
+
+        providers.push(LlmProviderCatalog {
+            id: descriptor.id.to_string(),
+            name: descriptor.name.to_string(),
+            requires_api_key: descriptor.requires_api_key,
+            requires_base_url: descriptor.requires_base_url,
+            has_api_key,
+            base_url,
+            status,
+            error,
+            models,
+        });
+    }
+
+    Ok(providers)
+}
+
+fn static_provider_models(
+    descriptor: &koharu_llm::providers::ProviderDescriptor,
+) -> Vec<LlmCatalogModel> {
+    match &descriptor.models {
+        ProviderCatalogModels::Static(models) => models
+            .iter()
+            .map(|model| LlmCatalogModel {
+                target: provider_target(descriptor.id, model.id),
+                name: model.name.to_string(),
+                languages: supported_locales(),
+            })
+            .collect(),
+        ProviderCatalogModels::Dynamic(_) => Vec::new(),
+    }
+}
+
+fn provider_config_from_settings(
+    state: &AppResources,
+    target: &LlmTarget,
+    options: Option<&LlmGenerationOptions>,
+) -> anyhow::Result<ProviderConfig> {
+    validate_target(target)?;
+    let provider_id = target
+        .provider_id
+        .as_deref()
+        .ok_or_else(|| anyhow::anyhow!("provider targets require provider_id"))?;
+    let config = app_config::load()?;
+    let stored = config.llm.providers.get(provider_id);
+
+    Ok(ProviderConfig {
+        http_client: state.runtime.http_client(),
+        api_key: get_saved_api_key(provider_id)?,
+        base_url: stored.and_then(|provider| provider.base_url.clone()),
+        temperature: options.and_then(|options| options.temperature),
+        max_tokens: options.and_then(|options| options.max_tokens),
+        custom_system_prompt: options.and_then(|options| options.custom_system_prompt.clone()),
+    })
+}
+
+async fn load_target(
+    state: &AppResources,
+    target: &LlmTarget,
+    options: Option<&LlmGenerationOptions>,
+) -> anyhow::Result<()> {
+    validate_target(target)?;
+    if state.llm.current_target().await.as_ref() == Some(target) && state.llm.ready().await {
+        return Ok(());
+    }
+
+    match target.kind {
+        LlmTargetKind::Local => {
+            let model = ModelId::from_str(&target.model_id)?;
+            state.llm.load_local(model).await;
+        }
+        LlmTargetKind::Provider => {
+            let provider_id = target
+                .provider_id
+                .as_deref()
+                .ok_or_else(|| anyhow::anyhow!("provider targets require provider_id"))?;
+            let provider = build_provider(
+                provider_id,
+                provider_config_from_settings(state, target, options)?,
+            )?;
+            state.llm.load_provider(target.clone(), provider).await?;
+        }
+    }
+
+    Ok(())
+}
+
+pub async fn ensure_target_ready(
+    state: &AppResources,
+    target: &LlmTarget,
+    options: Option<&LlmGenerationOptions>,
+) -> anyhow::Result<()> {
+    load_target(state, target, options).await?;
+    if target.kind != LlmTargetKind::Local {
+        return Ok(());
+    }
+
+    for _ in 0..300 {
+        let snapshot = state.llm.snapshot().await;
+        match snapshot.status {
+            LlmStateStatus::Ready if snapshot.target.as_ref() == Some(target) => return Ok(()),
+            LlmStateStatus::Failed if snapshot.target.as_ref() == Some(target) => {
+                anyhow::bail!(
+                    "{}",
+                    snapshot
+                        .error
+                        .unwrap_or_else(|| "LLM failed to load".to_string())
+                );
+            }
+            _ => {}
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+    }
+
+    anyhow::bail!("LLM failed to load within timeout");
+}
+
+pub async fn llm_catalog(
+    state: AppResources,
+    language: Option<&str>,
+) -> anyhow::Result<LlmCatalog> {
+    Ok(LlmCatalog {
+        local_models: local_catalog_models(state.llm.is_cpu(), language),
+        providers: provider_catalog(&state).await?,
+    })
+}
+
+#[instrument(level = "info", skip_all)]
+pub async fn llm_load(state: AppResources, payload: LlmLoadRequest) -> anyhow::Result<()> {
+    load_target(&state, &payload.target, payload.options.as_ref()).await
+}
+
+pub async fn llm_offload(state: AppResources) -> anyhow::Result<()> {
+    state.llm.offload().await;
+    Ok(())
+}
+
+pub async fn llm_ready(state: AppResources) -> anyhow::Result<bool> {
+    Ok(state.llm.ready().await)
+}
+
+#[instrument(level = "info", skip_all)]
+pub async fn llm_generate(
+    state: AppResources,
+    document_id: &str,
+    text_block_index: Option<usize>,
+    language: Option<&str>,
+) -> anyhow::Result<()> {
+    let mut doc = state.cache.get(document_id).await?;
+
+    match text_block_index {
+        Some(block_index) => {
+            let text_block = doc
+                .text_blocks
+                .get_mut(block_index)
+                .ok_or_else(|| anyhow::anyhow!("Text block not found"))?;
+            state.llm.translate(text_block, language).await?;
+        }
+        None => {
+            state.llm.translate(&mut doc, language).await?;
+        }
+    }
+
+    state.cache.put(&doc).await?;
+    Ok(())
+}
+
+pub async fn get_document_for_llm(
+    state: AppResources,
+    document_id: &str,
+) -> anyhow::Result<koharu_core::Document> {
+    state.cache.get(document_id).await
+}
+
 #[cfg(test)]
 mod tests {
     use koharu_core::Document;

koharu-app/src/manifest.rs

@@ -0,0 +1,104 @@
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+use koharu_core::TextBlock;
+use serde::{Deserialize, Serialize};
+
+/// Per-page manifest stored as JSON at `~/.koharu/pages/{id}.json`.
+///
+/// JSON is used instead of TOML because `TextBlock` contains types that TOML
+/// cannot represent (tuples in `FontPrediction::top_fonts`, fixed-size arrays
+/// in `line_polygons`, binary image data in `rendered`).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PageManifest {
+    pub id: String,
+    /// Blob hash of the original image.
+    pub source: String,
+    pub name: String,
+    pub width: u32,
+    pub height: u32,
+    #[serde(default)]
+    pub layers: LayerRefs,
+    #[serde(default)]
+    pub text_blocks: Vec<TextBlock>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct LayerRefs {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub segment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub inpainted: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub rendered: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub brush_layer: Option<String>,
+}
+
+/// Manages manifest files at `~/.koharu/pages/`.
+#[derive(Clone)]
+pub struct ManifestStore {
+    root: PathBuf,
+}
+
+impl ManifestStore {
+    pub fn new(root: impl Into<PathBuf>) -> Result<Self> {
+        let root = root.into();
+        std::fs::create_dir_all(&root)?;
+        Ok(Self { root })
+    }
+
+    pub fn save(&self, manifest: &PageManifest) -> Result<()> {
+        let path = self.manifest_path(&manifest.id);
+        let content =
+            serde_json::to_string_pretty(manifest).context("Failed to serialize manifest")?;
+        std::fs::write(&path, content)
+            .with_context(|| format!("Failed to write manifest {}", manifest.id))?;
+        Ok(())
+    }
+
+    pub fn load(&self, id: &str) -> Result<PageManifest> {
+        let path = self.manifest_path(id);
+        let content =
+            std::fs::read_to_string(&path).with_context(|| format!("Manifest not found: {id}"))?;
+        serde_json::from_str(&content).with_context(|| format!("Failed to parse manifest {id}"))
+    }
+
+    pub fn load_all(&self) -> Result<Vec<PageManifest>> {
+        let mut manifests = Vec::new();
+        if let Ok(entries) = std::fs::read_dir(&self.root) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.extension().is_some_and(|e| e == "json")
+                    && let Ok(content) = std::fs::read_to_string(&path)
+                    && let Ok(manifest) = serde_json::from_str::<PageManifest>(&content)
+                {
+                    manifests.push(manifest);
+                }
+            }
+        }
+        Ok(manifests)
+    }
+
+    pub fn replace_all(&self, manifests: &[PageManifest]) -> Result<()> {
+        if let Ok(entries) = std::fs::read_dir(&self.root) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.extension().is_some_and(|e| e == "json") {
+                    std::fs::remove_file(&path)
+                        .with_context(|| format!("Failed to remove manifest {}", path.display()))?;
+                }
+            }
+        }
+
+        for manifest in manifests {
+            self.save(manifest)?;
+        }
+
+        Ok(())
+    }
+
+    fn manifest_path(&self, id: &str) -> PathBuf {
+        self.root.join(format!("{id}.json"))
+    }
+}

koharu-app/src/ml.rs

@@ -5,16 +5,21 @@ use std::{
 
 use anyhow::Result;
 use image::DynamicImage;
-use koharu_core::{Document, FontPrediction, SerializableDynamicImage, TextBlock, TextDirection};
+use koharu_core::{
+    Document, FontFaceInfo, FontPrediction, SerializableDynamicImage, TextBlock, TextDirection,
+    TextShaderEffect, TextStrokeStyle,
+};
 use koharu_llm::paddleocr_vl::{self as paddleocr_vl_llm, PaddleOcrVl, PaddleOcrVlTask};
 use koharu_llm::safe::llama_backend::LlamaBackend;
 use koharu_runtime::RuntimeManager;
+use tracing::instrument;
 
 use koharu_ml::comic_text_detector::{self, ComicTextDetector, crop_text_block_bbox};
 use koharu_ml::font_detector::{self, FontDetector};
 use koharu_ml::lama::{self, Lama};
 use koharu_ml::pp_doclayout_v3::{self, LayoutRegion, PPDocLayoutV3};
 
+use crate::AppResources;
 const NEAR_BLACK_THRESHOLD: u8 = 12;
 const GRAY_NEAR_BLACK_THRESHOLD: u8 = 60;
 const NEAR_WHITE_THRESHOLD: u8 = 12;
@@ -358,6 +363,61 @@ fn overlap_area(a: [f32; 4], b: [f32; 4]) -> f32 {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Operations (merged from ops/vision.rs)
+// ---------------------------------------------------------------------------
+
+#[instrument(level = "info", skip_all)]
+pub async fn detect(state: AppResources, document_id: &str) -> Result<()> {
+    let mut doc = state.cache.get(document_id).await?;
+    state.ml.detect(&mut doc).await?;
+    state.cache.put(&doc).await?;
+    Ok(())
+}
+
+#[instrument(level = "info", skip_all)]
+pub async fn ocr(state: AppResources, document_id: &str) -> Result<()> {
+    let mut doc = state.cache.get(document_id).await?;
+    state.ml.ocr(&mut doc).await?;
+    state.cache.put(&doc).await?;
+    Ok(())
+}
+
+#[instrument(level = "info", skip_all)]
+pub async fn inpaint(state: AppResources, document_id: &str) -> Result<()> {
+    let mut doc = state.cache.get(document_id).await?;
+    state.ml.inpaint(&mut doc).await?;
+    state.cache.put(&doc).await?;
+    Ok(())
+}
+
+#[instrument(level = "info", skip_all)]
+pub async fn render(
+    state: AppResources,
+    document_id: &str,
+    text_block_index: Option<usize>,
+    shader_effect: Option<TextShaderEffect>,
+    shader_stroke: Option<TextStrokeStyle>,
+    font_family: Option<&str>,
+) -> Result<()> {
+    let mut doc = state.cache.get(document_id).await?;
+
+    state.renderer.render(
+        &mut doc,
+        text_block_index,
+        shader_effect.unwrap_or_default(),
+        shader_stroke,
+        font_family,
+    )?;
+
+    state.cache.put(&doc).await?;
+    Ok(())
+}
+
+pub async fn list_font_families(state: AppResources) -> Result<Vec<FontFaceInfo>> {
+    state.renderer.available_fonts()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

koharu-app/src/operations.rs

@@ -1 +0,0 @@
-pub use crate::ops::*;

koharu-app/src/ops/llm.rs

@@ -1,191 +0,0 @@
-use std::str::FromStr;
-use std::sync::Arc;
-
-use koharu_core::commands::{
-    ApiKeyGetPayload, ApiKeyResult, ApiKeySetPayload, IndexPayload, LlmGeneratePayload,
-    LlmListPayload, LlmLoadPayload,
-};
-use koharu_llm::ModelId;
-use koharu_llm::api::{ALL_API_PROVIDERS, OPENAI_COMPATIBLE_ID};
-use koharu_llm::providers::{get_saved_api_key, openai_compatible, set_saved_api_key};
-pub use openai_compatible::PingResult;
-use reqwest_middleware::ClientWithMiddleware;
-use strum::IntoEnumIterator;
-use tracing::instrument;
-
-use crate::{
-    AppResources, llm,
-    state_tx::{self, ChangedField},
-};
-
-#[instrument(level = "debug", skip_all, fields(provider = %payload.provider))]
-pub async fn get_api_key(
-    _state: AppResources,
-    payload: ApiKeyGetPayload,
-) -> anyhow::Result<ApiKeyResult> {
-    match get_saved_api_key(&payload.provider) {
-        Ok(Some(key)) => Ok(ApiKeyResult { api_key: Some(key) }),
-        Ok(None) => Ok(ApiKeyResult { api_key: None }),
-        Err(err) => {
-            tracing::error!(%err, "keyring read failed");
-            Err(err)
-        }
-    }
-}
-
-#[instrument(level = "debug", skip_all, fields(provider = %payload.provider))]
-pub async fn set_api_key(_state: AppResources, payload: ApiKeySetPayload) -> anyhow::Result<()> {
-    match set_saved_api_key(&payload.provider, &payload.api_key) {
-        Ok(()) => Ok(()),
-        Err(err) => {
-            tracing::error!(%err, "keyring write failed");
-            Err(err)
-        }
-    }
-}
-
-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 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 {
-        ModelId::VntlLlama3_8Bv2 => 100,
-        ModelId::Lfm2_350mEnjpMt => 200 / cpu_factor,
-        ModelId::SakuraGalTransl7Bv3_7 => 300 / zh_locale_factor,
-        ModelId::Sakura1_5bQwen2_5v1_0 => 400 / zh_locale_factor / cpu_factor,
-        ModelId::HunyuanMT7B => 500 / non_zh_en_locale_factor,
-    });
-
-    let mut result: Vec<llm::ModelInfo> = models.into_iter().map(llm::ModelInfo::new).collect();
-
-    for provider in ALL_API_PROVIDERS {
-        for model in provider.models {
-            result.push(llm::ModelInfo::api(provider.id, model.id));
-        }
-    }
-
-    if let Some(base_url) = payload
-        .openai_compatible_base_url
-        .as_deref()
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-    {
-        let api_key = match get_saved_api_key(OPENAI_COMPATIBLE_ID) {
-            Ok(value) => value,
-            Err(err) => {
-                tracing::warn!(%err, "failed to read openai-compatible API key");
-                None
-            }
-        };
-
-        match openai_compatible::list_models(
-            state.runtime.http_client(),
-            base_url,
-            api_key.as_deref(),
-        )
-        .await
-        {
-            Ok(models) => {
-                for model in models {
-                    result.push(llm::ModelInfo::api(OPENAI_COMPATIBLE_ID, &model));
-                }
-            }
-            Err(err) => {
-                tracing::warn!(%err, "failed to list openai-compatible models");
-            }
-        }
-    }
-
-    Ok(result)
-}
-
-#[instrument(level = "info", skip_all)]
-pub async fn llm_load(state: AppResources, payload: LlmLoadPayload) -> anyhow::Result<()> {
-    if payload.id.contains(':') {
-        let (provider_id, model_id) = payload.id.split_once(':').unwrap();
-        let api_key = match payload.api_key {
-            Some(key) if !key.trim().is_empty() => Some(key),
-            _ => get_saved_api_key(provider_id)?,
-        };
-        state
-            .llm
-            .load_api(
-                provider_id,
-                model_id,
-                koharu_llm::providers::ProviderConfig {
-                    http_client: state.runtime.http_client(),
-                    api_key,
-                    base_url: payload.base_url,
-                    temperature: payload.temperature,
-                    max_tokens: payload.max_tokens,
-                    custom_system_prompt: payload.custom_system_prompt,
-                },
-            )
-            .await?;
-    } else {
-        let id = ModelId::from_str(&payload.id)?;
-        state.llm.load(id).await;
-    }
-    Ok(())
-}
-
-pub async fn llm_offload(state: AppResources) -> anyhow::Result<()> {
-    state.llm.offload().await;
-    Ok(())
-}
-
-pub async fn llm_ready(state: AppResources) -> anyhow::Result<bool> {
-    Ok(state.llm.ready().await)
-}
-
-#[instrument(level = "info", skip_all)]
-pub async fn llm_generate(state: AppResources, payload: LlmGeneratePayload) -> anyhow::Result<()> {
-    let mut updated = state_tx::read_doc(&state.state, payload.index).await?;
-    let target_language = payload.language.as_deref();
-
-    match payload.text_block_index {
-        Some(block_index) => {
-            let text_block = updated
-                .text_blocks
-                .get_mut(block_index)
-                .ok_or_else(|| anyhow::anyhow!("Text block not found"))?;
-            state.llm.translate(text_block, target_language).await?;
-        }
-        None => {
-            state.llm.translate(&mut updated, target_language).await?;
-        }
-    }
-
-    state_tx::update_doc(
-        &state.state,
-        payload.index,
-        updated,
-        &[ChangedField::TextBlocks],
-    )
-    .await
-}
-
-pub async fn llm_ping(
-    http_client: Arc<ClientWithMiddleware>,
-    base_url: &str,
-    api_key: Option<&str>,
-) -> anyhow::Result<openai_compatible::PingResult> {
-    openai_compatible::ping(http_client, base_url, api_key).await
-}
-
-pub async fn get_document_for_llm(
-    state: AppResources,
-    payload: IndexPayload,
-) -> anyhow::Result<koharu_core::Document> {
-    state_tx::read_doc(&state.state, payload.index).await
-}

koharu-app/src/ops/mod.rs

@@ -1,13 +0,0 @@
-mod core;
-mod edit;
-mod llm;
-mod process;
-mod utils;
-mod vision;
-
-pub use core::*;
-pub use edit::*;
-pub use llm::*;
-pub use process::*;
-pub use utils::{InpaintRegionExt, load_documents};
-pub use vision::*;

koharu-app/src/ops/process.rs

@@ -1,56 +0,0 @@
-use std::sync::{
-    Arc,
-    atomic::{AtomicBool, Ordering},
-};
-
-use koharu_core::commands::ProcessRequest;
-use koharu_llm::providers::get_saved_api_key;
-use uuid::Uuid;
-
-use crate::AppResources;
-
-pub async fn process(state: AppResources, payload: ProcessRequest) -> anyhow::Result<String> {
-    let mut payload = payload;
-    if let Some(model_id) = payload.llm_model_id.as_deref()
-        && payload.llm_api_key.is_none()
-        && model_id.contains(':')
-    {
-        let (provider_id, _) = model_id
-            .split_once(':')
-            .ok_or_else(|| anyhow::anyhow!("invalid api model id"))?;
-        payload.llm_api_key = get_saved_api_key(provider_id)?;
-    }
-
-    {
-        let guard = state.pipeline.read().await;
-        if guard.is_some() {
-            anyhow::bail!("A processing pipeline is already running");
-        }
-    }
-
-    let job_id = Uuid::new_v4().to_string();
-    let cancel = Arc::new(AtomicBool::new(false));
-    {
-        let mut guard = state.pipeline.write().await;
-        *guard = Some(crate::pipeline::PipelineHandle {
-            id: job_id.clone(),
-            cancel: cancel.clone(),
-        });
-    }
-
-    let resources = state.clone();
-    let job_id_for_task = job_id.clone();
-    tokio::spawn(async move {
-        crate::pipeline::run_pipeline(resources, payload, cancel, job_id_for_task).await;
-    });
-
-    Ok(job_id)
-}
-
-pub async fn process_cancel(state: AppResources) -> anyhow::Result<()> {
-    let guard = state.pipeline.read().await;
-    if let Some(handle) = guard.as_ref() {
-        handle.cancel.store(true, Ordering::Relaxed);
-    }
-    Ok(())
-}

koharu-app/src/ops/vision.rs

@@ -1,72 +0,0 @@
-use koharu_core::FontFaceInfo;
-use koharu_core::commands::{IndexPayload, RenderPayload};
-use tracing::instrument;
-
-use crate::{
-    AppResources,
-    state_tx::{self, ChangedField},
-};
-
-#[instrument(level = "info", skip_all)]
-pub async fn detect(state: AppResources, payload: IndexPayload) -> anyhow::Result<()> {
-    let mut snapshot = state_tx::read_doc(&state.state, payload.index).await?;
-    state.ml.detect(&mut snapshot).await?;
-    state_tx::update_doc(
-        &state.state,
-        payload.index,
-        snapshot,
-        &[ChangedField::TextBlocks, ChangedField::Segment],
-    )
-    .await
-}
-
-#[instrument(level = "info", skip_all)]
-pub async fn ocr(state: AppResources, payload: IndexPayload) -> anyhow::Result<()> {
-    let mut snapshot = state_tx::read_doc(&state.state, payload.index).await?;
-    state.ml.ocr(&mut snapshot).await?;
-    state_tx::update_doc(
-        &state.state,
-        payload.index,
-        snapshot,
-        &[ChangedField::TextBlocks],
-    )
-    .await
-}
-
-#[instrument(level = "info", skip_all)]
-pub async fn inpaint(state: AppResources, payload: IndexPayload) -> anyhow::Result<()> {
-    let mut snapshot = state_tx::read_doc(&state.state, payload.index).await?;
-    state.ml.inpaint(&mut snapshot).await?;
-    state_tx::update_doc(
-        &state.state,
-        payload.index,
-        snapshot,
-        &[ChangedField::Inpainted],
-    )
-    .await
-}
-
-#[instrument(level = "info", skip_all)]
-pub async fn render(state: AppResources, payload: RenderPayload) -> anyhow::Result<()> {
-    let mut updated = state_tx::read_doc(&state.state, payload.index).await?;
-
-    state.renderer.render(
-        &mut updated,
-        payload.text_block_index,
-        payload.shader_effect.unwrap_or_default(),
-        payload.shader_stroke,
-        payload.font_family.as_deref(),
-    )?;
-
-    state_tx::update_doc(
-        &state.state,
-        payload.index,
-        updated,
-        &[ChangedField::TextBlocks, ChangedField::Rendered],
-    )
-    .await
-}
-
-pub async fn list_font_families(state: AppResources) -> anyhow::Result<Vec<FontFaceInfo>> {
-    state.renderer.available_fonts()
-}

koharu-app/src/page_cache.rs

@@ -0,0 +1,289 @@
+use std::num::NonZeroUsize;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use anyhow::{Context, Result};
+use image::DynamicImage;
+use lru::LruCache;
+use tokio::sync::RwLock;
+
+use koharu_core::{Document, DocumentSummary, FileEntry};
+
+use crate::blob_store::BlobStore;
+use crate::manifest::{ManifestStore, PageManifest};
+
+const DEFAULT_CAPACITY: usize = 5;
+
+#[derive(Clone)]
+pub struct PageCache {
+    cache: Arc<RwLock<LruCache<String, Document>>>,
+    pub(crate) blobs: BlobStore,
+    manifests: ManifestStore,
+}
+
+impl PageCache {
+    pub fn new(blobs: BlobStore, manifests: ManifestStore) -> Self {
+        Self {
+            cache: Arc::new(RwLock::new(LruCache::new(
+                NonZeroUsize::new(DEFAULT_CAPACITY).unwrap(),
+            ))),
+            blobs,
+            manifests,
+        }
+    }
+
+    /// Get a page, loading from disk if not cached.
+    pub async fn get(&self, id: &str) -> Result<Document> {
+        // Check cache first
+        {
+            let mut cache = self.cache.write().await;
+            if let Some(doc) = cache.get(id) {
+                return Ok(doc.clone());
+            }
+        }
+        // Cache miss -- load from manifest + blobs
+        let doc = self.load_from_disk(id)?;
+        let mut cache = self.cache.write().await;
+        cache.put(id.to_string(), doc.clone());
+        Ok(doc)
+    }
+
+    /// Update a page in cache and save manifest + blobs to disk.
+    pub async fn put(&self, doc: &Document) -> Result<()> {
+        // Encode layers to blobs and save manifest
+        self.save_to_disk(doc)?;
+        // Update cache
+        let mut cache = self.cache.write().await;
+        cache.put(doc.id.clone(), doc.clone());
+        Ok(())
+    }
+
+    /// Evict a page from cache (does not delete from disk).
+    pub async fn evict(&self, id: &str) {
+        let mut cache = self.cache.write().await;
+        cache.pop(id);
+    }
+
+    /// Save a manifest without loading/putting the full document.
+    pub fn save_manifest(&self, manifest: &PageManifest) -> Result<()> {
+        self.manifests.save(manifest)
+    }
+
+    pub fn list_documents(&self) -> Result<Vec<DocumentSummary>> {
+        let mut entries: Vec<DocumentSummary> = self
+            .manifests
+            .load_all()?
+            .into_iter()
+            .map(|manifest| DocumentSummary {
+                id: manifest.id,
+                name: manifest.name,
+                width: manifest.width,
+                height: manifest.height,
+                has_segment: manifest.layers.segment.is_some(),
+                has_inpainted: manifest.layers.inpainted.is_some(),
+                has_rendered: manifest.layers.rendered.is_some(),
+                has_brush_layer: manifest.layers.brush_layer.is_some(),
+                text_block_count: manifest.text_blocks.len(),
+            })
+            .collect();
+        entries.sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.id.cmp(&b.id)));
+        Ok(entries)
+    }
+
+    pub async fn replace_manifests(&self, manifests: &[PageManifest]) -> Result<()> {
+        self.manifests.replace_all(manifests)?;
+        let mut cache = self.cache.write().await;
+        cache.clear();
+        Ok(())
+    }
+
+    pub fn import_files(&self, inputs: Vec<FileEntry>) -> Result<Vec<PageManifest>> {
+        use image::GenericImageView;
+        use rayon::iter::{IntoParallelIterator, ParallelIterator};
+
+        let manifests: Result<Vec<PageManifest>> = inputs
+            .into_par_iter()
+            .map(|file| {
+                let image = image::load_from_memory(&file.data)
+                    .map_err(|error| anyhow::anyhow!("failed to decode {}: {error}", file.name))?;
+                let (width, height) = image.dimensions();
+                let id = blake3::hash(&file.data).to_hex().to_string();
+                let source = self.blobs.put(&file.data)?;
+                let name = Path::new(&file.name)
+                    .file_stem()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    .to_string();
+
+                Ok(PageManifest {
+                    id,
+                    source,
+                    name,
+                    width,
+                    height,
+                    layers: crate::manifest::LayerRefs::default(),
+                    text_blocks: Vec::new(),
+                })
+            })
+            .collect();
+
+        let mut manifests = manifests?;
+        manifests.sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.id.cmp(&b.id)));
+        Ok(manifests)
+    }
+
+    fn load_from_disk(&self, id: &str) -> Result<Document> {
+        let manifest = self.manifests.load(id)?;
+
+        let image_bytes = self.blobs
+            .get(&manifest.source)
+            .with_context(|| format!("Source blob not found: {}", manifest.source))?;
+        let image =
+            image::load_from_memory(&image_bytes).context("Failed to decode source image")?;
+
+        // Load layers from blob store
+        let segment = self.load_layer(&manifest.layers.segment)?;
+        let inpainted = self.load_layer(&manifest.layers.inpainted)?;
+        let rendered = self.load_layer(&manifest.layers.rendered)?;
+        let brush_layer = self.load_layer(&manifest.layers.brush_layer)?;
+
+        Ok(Document {
+            id: manifest.id,
+            path: PathBuf::from(&manifest.name),
+            name: manifest.name,
+            image: image.into(),
+            width: manifest.width,
+            height: manifest.height,
+            text_blocks: manifest.text_blocks,
+            segment: segment.map(Into::into),
+            inpainted: inpainted.map(Into::into),
+            rendered: rendered.map(Into::into),
+            brush_layer: brush_layer.map(Into::into),
+        })
+    }
+
+    fn save_to_disk(&self, doc: &Document) -> Result<PageManifest> {
+        let encode = |img: &koharu_core::SerializableDynamicImage| -> Result<String> {
+            let mut buf = std::io::Cursor::new(Vec::new());
+            img.0
+                .write_to(&mut buf, image::ImageFormat::WebP)
+                .context("Failed to encode layer")?;
+            self.blobs.put(&buf.into_inner())
+        };
+
+        let segment = doc.segment.as_ref().map(encode).transpose()?;
+        let inpainted = doc.inpainted.as_ref().map(encode).transpose()?;
+        let rendered = doc.rendered.as_ref().map(encode).transpose()?;
+        let brush_layer = doc.brush_layer.as_ref().map(encode).transpose()?;
+        let source = match self.manifests.load(&doc.id) {
+            Ok(existing) if !existing.source.is_empty() => existing.source,
+            _ => {
+                let mut buf = std::io::Cursor::new(Vec::new());
+                let format =
+                    image::ImageFormat::from_path(&doc.path).unwrap_or(image::ImageFormat::Png);
+                doc.image
+                    .0
+                    .write_to(&mut buf, format)
+                    .context("Failed to encode source image")?;
+                self.blobs.put(&buf.into_inner())?
+            }
+        };
+
+        let manifest = PageManifest {
+            id: doc.id.clone(),
+            source,
+            name: doc.name.clone(),
+            width: doc.width,
+            height: doc.height,
+            layers: crate::manifest::LayerRefs {
+                segment,
+                inpainted,
+                rendered,
+                brush_layer,
+            },
+            text_blocks: doc.text_blocks.clone(),
+        };
+
+        self.manifests.save(&manifest)?;
+        Ok(manifest)
+    }
+
+    fn load_layer(&self, hash: &Option<String>) -> Result<Option<DynamicImage>> {
+        match hash {
+            Some(h) if !h.is_empty() => {
+                let bytes = self.blobs.get(h)?;
+                let img = image::load_from_memory(&bytes)
+                    .with_context(|| format!("Failed to decode layer blob {h}"))?;
+                Ok(Some(img))
+            }
+            _ => Ok(None),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+    use std::path::PathBuf;
+
+    use image::{DynamicImage, ImageFormat};
+    use koharu_core::FileEntry;
+
+    use super::PageCache;
+    use crate::{blob_store::BlobStore, manifest::ManifestStore};
+
+    fn cache() -> (tempfile::TempDir, PageCache) {
+        let tempdir = tempfile::tempdir().unwrap();
+        let blobs = BlobStore::new(tempdir.path().join("blobs")).unwrap();
+        let manifests = ManifestStore::new(tempdir.path().join("pages")).unwrap();
+        (tempdir, PageCache::new(blobs, manifests))
+    }
+
+    #[test]
+    fn import_files_stores_source_as_blob_hash() {
+        let (_tempdir, cache) = cache();
+
+        let mut encoded = Cursor::new(Vec::new());
+        DynamicImage::new_rgba8(4, 5)
+            .write_to(&mut encoded, ImageFormat::Png)
+            .unwrap();
+
+        let manifests = cache
+            .import_files(vec![FileEntry {
+                name: "page.png".to_string(),
+                data: encoded.into_inner(),
+            }])
+            .unwrap();
+
+        assert_eq!(manifests.len(), 1);
+        assert_eq!(manifests[0].name, "page");
+        assert!(!manifests[0].source.is_empty());
+        assert!(cache.blobs.exists(&manifests[0].source));
+    }
+
+    #[test]
+    fn load_from_disk_reads_source_blob() {
+        let (_tempdir, cache) = cache();
+
+        let mut encoded = Cursor::new(Vec::new());
+        DynamicImage::new_rgba8(4, 5)
+            .write_to(&mut encoded, ImageFormat::Png)
+            .unwrap();
+
+        let manifest = cache
+            .import_files(vec![FileEntry {
+                name: "page.png".to_string(),
+                data: encoded.into_inner(),
+            }])
+            .unwrap()
+            .pop()
+            .unwrap();
+
+        cache.save_manifest(&manifest).unwrap();
+        let document = cache.load_from_disk(&manifest.id).unwrap();
+
+        assert_eq!(document.name, "page");
+        assert_eq!(document.width, 4);
+        assert_eq!(document.height, 5);
+    }
+}

koharu-app/src/pipeline.rs

@@ -1,4 +1,4 @@
-use std::str::FromStr;
+use std::collections::HashMap;
 use std::sync::{
     Arc,
     atomic::{AtomicBool, Ordering},
@@ -6,30 +6,28 @@ use std::sync::{
 use std::time::Duration;
 
 use koharu_core::commands::ProcessRequest;
-use koharu_core::events::{PipelineProgress, PipelineStatus, PipelineStep};
-use koharu_llm::ModelId;
-use once_cell::sync::Lazy;
-use tokio::sync::broadcast;
-
-use crate::{
-    AppResources,
-    state_tx::{self, ChangedField},
-};
+use koharu_core::events::{PipelineStatus, PipelineStep};
+use koharu_core::{JobState, JobStatus};
+use tokio::sync::RwLock;
+use uuid::Uuid;
+
+use crate::AppResources;
+use crate::llm::ensure_target_ready;
+
+pub type Jobs = Arc<RwLock<HashMap<String, JobState>>>;
 
 pub struct PipelineHandle {
     pub id: String,
     pub cancel: Arc<AtomicBool>,
 }
 
-static PIPELINE_TX: Lazy<broadcast::Sender<PipelineProgress>> =
-    Lazy::new(|| broadcast::channel(256).0);
-
-pub fn subscribe() -> broadcast::Receiver<PipelineProgress> {
-    PIPELINE_TX.subscribe()
-}
-
-fn emit(progress: PipelineProgress) {
-    let _ = PIPELINE_TX.send(progress);
+#[derive(Clone, Copy)]
+struct JobProgress {
+    current_document: usize,
+    total_documents: usize,
+    current_step_index: usize,
+    total_steps: usize,
+    overall_percent: u8,
 }
 
 fn compute_percent(doc: usize, step: usize, total_docs: usize, total_steps: usize) -> u8 {
@@ -41,58 +39,142 @@ fn compute_percent(doc: usize, step: usize, total_docs: usize, total_steps: usiz
     ((done_units as f64 / total_units as f64) * 100.0).round() as u8
 }
 
-pub async fn run_pipeline(
+async fn update_job(jobs: &Jobs, job: JobState) {
+    let terminal = !matches!(job.status, JobStatus::Running);
+    let mut guard = jobs.write().await;
+    if terminal {
+        guard.remove(&job.id);
+    } else {
+        guard.insert(job.id.clone(), job);
+    }
+}
+
+fn make_job_state(
+    job_id: &str,
+    status: PipelineStatus,
+    step: Option<PipelineStep>,
+    progress: JobProgress,
+) -> JobState {
+    let (job_status, error) = match status {
+        PipelineStatus::Running => (JobStatus::Running, None),
+        PipelineStatus::Completed => (JobStatus::Completed, None),
+        PipelineStatus::Cancelled => (JobStatus::Cancelled, None),
+        PipelineStatus::Failed(message) => (JobStatus::Failed, Some(message)),
+    };
+
+    JobState {
+        id: job_id.to_string(),
+        kind: "pipeline".to_string(),
+        status: job_status,
+        step: step.map(|step| step.to_string()),
+        current_document: progress.current_document,
+        total_documents: progress.total_documents,
+        current_step_index: progress.current_step_index,
+        total_steps: progress.total_steps,
+        overall_percent: progress.overall_percent,
+        error,
+    }
+}
+
+pub async fn process(
+    state: AppResources,
+    payload: ProcessRequest,
+    jobs: Jobs,
+) -> anyhow::Result<String> {
+    {
+        let guard = state.pipeline.read().await;
+        if guard.is_some() {
+            anyhow::bail!("A processing pipeline is already running");
+        }
+    }
+
+    let job_id = Uuid::new_v4().to_string();
+    let cancel = Arc::new(AtomicBool::new(false));
+    {
+        let mut guard = state.pipeline.write().await;
+        *guard = Some(PipelineHandle {
+            id: job_id.clone(),
+            cancel: cancel.clone(),
+        });
+    }
+
+    let resources = state.clone();
+    let job_id_for_task = job_id.clone();
+    tokio::spawn(async move {
+        run_pipeline(resources, payload, cancel, job_id_for_task, jobs).await;
+    });
+
+    Ok(job_id)
+}
+
+pub async fn process_cancel(state: AppResources) -> anyhow::Result<()> {
+    let guard = state.pipeline.read().await;
+    if let Some(handle) = guard.as_ref() {
+        handle.cancel.store(true, Ordering::Relaxed);
+    }
+    Ok(())
+}
+
+async fn run_pipeline(
     resources: AppResources,
     request: ProcessRequest,
     cancel: Arc<AtomicBool>,
     job_id: String,
+    jobs: Jobs,
 ) {
-    let result = run_pipeline_inner(&resources, &request, &cancel, &job_id).await;
+    let result = run_pipeline_inner(&resources, &request, &cancel, &job_id, &jobs).await;
 
-    let total_docs = match request.index {
+    let total_docs = match request.document_id {
         Some(_) => 1,
-        None => resources.state.read().await.documents.len(),
+        None => resources
+            .cache
+            .list_documents()
+            .map(|entries| entries.len())
+            .unwrap_or(0),
     };
 
-    match result {
-        Ok(()) if cancel.load(Ordering::Relaxed) => {
-            emit(PipelineProgress {
-                job_id: job_id.clone(),
-                status: PipelineStatus::Cancelled,
-                step: None,
+    let final_state = match result {
+        Ok(()) if cancel.load(Ordering::Relaxed) => make_job_state(
+            &job_id,
+            PipelineStatus::Cancelled,
+            None,
+            JobProgress {
                 current_document: total_docs,
                 total_documents: total_docs,
                 current_step_index: 0,
                 total_steps: PipelineStep::ALL.len(),
                 overall_percent: 0,
-            });
-        }
-        Ok(()) => {
-            emit(PipelineProgress {
-                job_id: job_id.clone(),
-                status: PipelineStatus::Completed,
-                step: None,
+            },
+        ),
+        Ok(()) => make_job_state(
+            &job_id,
+            PipelineStatus::Completed,
+            None,
+            JobProgress {
                 current_document: total_docs,
                 total_documents: total_docs,
                 current_step_index: PipelineStep::ALL.len(),
                 total_steps: PipelineStep::ALL.len(),
                 overall_percent: 100,
-            });
-        }
+            },
+        ),
         Err(err) => {
             tracing::error!("Pipeline failed: {err:#}");
-            emit(PipelineProgress {
-                job_id: job_id.clone(),
-                status: PipelineStatus::Failed(err.to_string()),
-                step: None,
-                current_document: 0,
-                total_documents: total_docs,
-                current_step_index: 0,
-                total_steps: PipelineStep::ALL.len(),
-                overall_percent: 0,
-            });
+            make_job_state(
+                &job_id,
+                PipelineStatus::Failed(err.to_string()),
+                None,
+                JobProgress {
+                    current_document: 0,
+                    total_documents: total_docs,
+                    current_step_index: 0,
+                    total_steps: PipelineStep::ALL.len(),
+                    overall_percent: 0,
+                },
+            )
         }
-    }
+    };
+    update_job(&jobs, final_state).await;
 
     let mut guard = resources.pipeline.write().await;
     *guard = None;
@@ -103,97 +185,69 @@ async fn run_pipeline_inner(
     req: &ProcessRequest,
     cancel: &Arc<AtomicBool>,
     job_id: &str,
+    jobs: &Jobs,
 ) -> anyhow::Result<()> {
-    let total_docs = {
-        let guard = res.state.read().await;
-        let len = guard.documents.len();
-        match req.index {
-            Some(i) if i >= len => anyhow::bail!("Document index {i} out of range (have {len})"),
-            Some(_) => 1,
-            None => len,
+    let entries = res.cache.list_documents()?;
+    let page_ids: Vec<String> = match req.document_id.as_deref() {
+        Some(id) => {
+            if !entries.iter().any(|p| p.id == id) {
+                anyhow::bail!("Document not found: {id}");
+            }
+            vec![id.to_string()]
         }
+        None => entries.into_iter().map(|p| p.id).collect(),
     };
 
+    let total_docs = page_ids.len();
     if total_docs == 0 {
         return Ok(());
     }
 
-    if let Some(model_id) = &req.llm_model_id
-        && !res.llm.ready().await
-    {
-        if model_id.contains(':') {
-            let (provider_id, model_part) = model_id.split_once(':').unwrap();
-            res.llm
-                .load_api(
-                    provider_id,
-                    model_part,
-                    koharu_llm::providers::ProviderConfig {
-                        http_client: res.runtime.http_client(),
-                        api_key: req.llm_api_key.clone(),
-                        base_url: req.llm_base_url.clone(),
-                        temperature: req.llm_temperature,
-                        max_tokens: req.llm_max_tokens,
-                        custom_system_prompt: req.llm_custom_system_prompt.clone(),
-                    },
-                )
-                .await?;
-        } else {
-            let id = ModelId::from_str(model_id)?;
-            res.llm.load(id).await;
-            for _ in 0..300 {
-                if res.llm.ready().await {
-                    break;
-                }
-                tokio::time::sleep(Duration::from_millis(100)).await;
-                if cancel.load(Ordering::Relaxed) {
-                    return Ok(());
-                }
-            }
-            if !res.llm.ready().await {
-                anyhow::bail!("LLM failed to load within timeout");
-            }
-        }
+    if let Some(llm) = &req.llm {
+        ensure_target_ready(res, &llm.target, llm.options.as_ref()).await?;
     }
 
-    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();
 
-    for (doc_ordinal, doc_index) in (start_index..end_index).enumerate() {
+    for (doc_ordinal, page_id) in page_ids.iter().enumerate() {
+        let mut doc = res.cache.get(page_id).await?;
+
         for (step_ordinal, step) in PipelineStep::ALL.iter().enumerate() {
             if cancel.load(Ordering::Relaxed) {
                 return Ok(());
             }
 
             let overall = compute_percent(doc_ordinal, step_ordinal, total_docs, total_steps);
-            emit(PipelineProgress {
-                job_id: job_id.to_string(),
-                status: PipelineStatus::Running,
-                step: Some(*step),
-                current_document: doc_ordinal,
-                total_documents: total_docs,
-                current_step_index: step_ordinal,
-                total_steps,
-                overall_percent: overall,
-            });
+            update_job(
+                jobs,
+                make_job_state(
+                    job_id,
+                    PipelineStatus::Running,
+                    Some(*step),
+                    JobProgress {
+                        current_document: doc_ordinal,
+                        total_documents: total_docs,
+                        current_step_index: step_ordinal,
+                        total_steps,
+                        overall_percent: overall,
+                    },
+                ),
+            )
+            .await;
 
             tokio::task::yield_now().await;
             tokio::time::sleep(Duration::from_millis(1)).await;
 
-            let mut snapshot = state_tx::read_doc(&res.state, doc_index).await?;
-
             match step {
-                PipelineStep::Detect => res.ml.detect(&mut snapshot).await?,
-                PipelineStep::Ocr => res.ml.ocr(&mut snapshot).await?,
-                PipelineStep::Inpaint => res.ml.inpaint(&mut snapshot).await?,
+                PipelineStep::Detect => res.ml.detect(&mut doc).await?,
+                PipelineStep::Ocr => res.ml.ocr(&mut doc).await?,
+                PipelineStep::Inpaint => res.ml.inpaint(&mut doc).await?,
                 PipelineStep::LlmGenerate => {
-                    res.llm
-                        .translate(&mut snapshot, req.language.as_deref())
-                        .await?;
+                    res.llm.translate(&mut doc, req.language.as_deref()).await?;
                 }
                 PipelineStep::Render => {
                     res.renderer.render(
-                        &mut snapshot,
+                        &mut doc,
                         None,
                         req.shader_effect.unwrap_or_default(),
                         req.shader_stroke.clone(),
@@ -202,15 +256,11 @@ async fn run_pipeline_inner(
                 }
             }
 
-            let changed = match step {
-                PipelineStep::Detect => &[ChangedField::TextBlocks, ChangedField::Segment][..],
-                PipelineStep::Ocr => &[ChangedField::TextBlocks][..],
-                PipelineStep::Inpaint => &[ChangedField::Inpainted][..],
-                PipelineStep::LlmGenerate => &[ChangedField::TextBlocks][..],
-                PipelineStep::Render => &[ChangedField::TextBlocks, ChangedField::Rendered][..],
-            };
-            state_tx::update_doc(&res.state, doc_index, snapshot, changed).await?;
+            // Save after each step (crash-safe)
+            res.cache.put(&doc).await?;
         }
+        // Evict from cache to free memory
+        res.cache.evict(page_id).await;
     }
 
     Ok(())

koharu-app/src/state_tx.rs

@@ -1,224 +0,0 @@
-use anyhow::Result;
-use koharu_core::{AppState, Document};
-use once_cell::sync::Lazy;
-use tokio::sync::broadcast;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, strum::Display)]
-pub enum ChangedField {
-    #[strum(serialize = "name")]
-    Name,
-    #[strum(serialize = "textBlocks")]
-    TextBlocks,
-    #[strum(serialize = "segment")]
-    Segment,
-    #[strum(serialize = "brushLayer")]
-    BrushLayer,
-    #[strum(serialize = "inpainted")]
-    Inpainted,
-    #[strum(serialize = "rendered")]
-    Rendered,
-}
-
-#[derive(Debug, Clone)]
-pub enum StateEvent {
-    DocumentsChanged,
-    DocumentChanged {
-        document_id: String,
-        revision: u64,
-        changed: Vec<String>,
-    },
-}
-
-static STATE_TX: Lazy<broadcast::Sender<StateEvent>> = Lazy::new(|| broadcast::channel(256).0);
-
-pub fn subscribe() -> broadcast::Receiver<StateEvent> {
-    STATE_TX.subscribe()
-}
-
-fn emit(event: StateEvent) {
-    let _ = STATE_TX.send(event);
-}
-
-fn serialize_changed_fields(changed: &[ChangedField]) -> Vec<String> {
-    changed.iter().map(ToString::to_string).collect()
-}
-
-pub async fn read_doc(state: &AppState, index: usize) -> Result<Document> {
-    let guard = state.read().await;
-    guard
-        .documents
-        .get(index)
-        .cloned()
-        .ok_or_else(|| anyhow::anyhow!("Document not found at index {index}"))
-}
-
-pub async fn list_docs(state: &AppState) -> Vec<Document> {
-    state.read().await.documents.clone()
-}
-
-pub async fn doc_count(state: &AppState) -> usize {
-    state.read().await.documents.len()
-}
-
-pub async fn find_doc_index(state: &AppState, document_id: &str) -> Result<usize> {
-    let guard = state.read().await;
-    guard
-        .documents
-        .iter()
-        .position(|document| document.id == document_id)
-        .ok_or_else(|| anyhow::anyhow!("Document not found: {document_id}"))
-}
-
-pub async fn replace_docs(state: &AppState, mut documents: Vec<Document>) -> Result<usize> {
-    for document in &mut documents {
-        document.prepare_for_store();
-    }
-
-    let count = documents.len();
-    let mut guard = state.write().await;
-    guard.documents = documents;
-    drop(guard);
-    emit(StateEvent::DocumentsChanged);
-    Ok(count)
-}
-
-pub async fn append_docs(state: &AppState, mut documents: Vec<Document>) -> Result<usize> {
-    for document in &mut documents {
-        document.prepare_for_store();
-    }
-
-    let mut guard = state.write().await;
-    guard.documents.extend(documents);
-    let count = guard.documents.len();
-    drop(guard);
-    emit(StateEvent::DocumentsChanged);
-    Ok(count)
-}
-
-pub async fn update_doc(
-    state: &AppState,
-    index: usize,
-    mut document: Document,
-    changed: &[ChangedField],
-) -> Result<()> {
-    document.prepare_for_store();
-    document.bump_revision();
-    let document_id = document.id.clone();
-    let revision = document.revision;
-
-    let mut guard = state.write().await;
-    let target = guard
-        .documents
-        .get_mut(index)
-        .ok_or_else(|| anyhow::anyhow!("Document not found at index {index}"))?;
-    *target = document;
-    drop(guard);
-    emit(StateEvent::DocumentChanged {
-        document_id,
-        revision,
-        changed: serialize_changed_fields(changed),
-    });
-    Ok(())
-}
-
-pub async fn mutate_doc<T, F>(
-    state: &AppState,
-    index: usize,
-    changed: &[ChangedField],
-    mutator: F,
-) -> Result<T>
-where
-    F: FnOnce(&mut Document) -> Result<T>,
-{
-    let mut guard = state.write().await;
-    let target = guard
-        .documents
-        .get_mut(index)
-        .ok_or_else(|| anyhow::anyhow!("Document not found at index {index}"))?;
-    let result = mutator(target)?;
-    target.prepare_for_store();
-    target.bump_revision();
-    let document_id = target.id.clone();
-    let revision = target.revision;
-    drop(guard);
-    emit(StateEvent::DocumentChanged {
-        document_id,
-        revision,
-        changed: serialize_changed_fields(changed),
-    });
-    Ok(result)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{
-        ChangedField, append_docs, find_doc_index, list_docs, mutate_doc, read_doc, replace_docs,
-        update_doc,
-    };
-    use koharu_core::{AppState, Document, State};
-    use std::sync::Arc;
-    use tokio::sync::RwLock;
-
-    fn test_state() -> AppState {
-        Arc::new(RwLock::new(State {
-            documents: vec![Default::default()],
-        }))
-    }
-
-    #[tokio::test]
-    async fn read_update_mutate_doc_round_trip() {
-        let state = test_state();
-
-        let mut doc = read_doc(&state, 0).await.expect("doc should exist");
-        doc.name = "before".to_string();
-        update_doc(&state, 0, doc, &[ChangedField::Name])
-            .await
-            .expect("update should work");
-
-        mutate_doc(&state, 0, &[ChangedField::Name], |doc| {
-            doc.name = "after".to_string();
-            Ok(())
-        })
-        .await
-        .expect("mutation should work");
-
-        let doc = read_doc(&state, 0).await.expect("doc should exist");
-        assert_eq!(doc.name, "after");
-    }
-
-    #[tokio::test]
-    async fn index_not_found_errors_are_stable() {
-        let state = test_state();
-        let err = read_doc(&state, 1)
-            .await
-            .expect_err("missing document should fail");
-        assert_eq!(err.to_string(), "Document not found at index 1");
-
-        let err = mutate_doc(&state, 1, &[ChangedField::Name], |_| Ok(()))
-            .await
-            .expect_err("missing document should fail");
-        assert_eq!(err.to_string(), "Document not found at index 1");
-    }
-
-    #[tokio::test]
-    async fn replace_append_and_find_doc_work() {
-        let state = test_state();
-        let first = Document {
-            id: "first".to_string(),
-            ..Default::default()
-        };
-        replace_docs(&state, vec![first])
-            .await
-            .expect("replace should work");
-        assert_eq!(list_docs(&state).await.len(), 1);
-
-        let second = Document {
-            id: "second".to_string(),
-            ..Default::default()
-        };
-        append_docs(&state, vec![second])
-            .await
-            .expect("append should work");
-        assert_eq!(find_doc_index(&state, "second").await.expect("find"), 1);
-    }
-}

koharu-app/src/{ops/utils.rs → utils.rs}

@@ -1,15 +1,14 @@
 use std::{io::Cursor, path::PathBuf};
 
 use image::{ImageFormat, RgbaImage};
-use koharu_core::commands::InpaintRegion;
-use koharu_core::{Document, SerializableDynamicImage};
+use koharu_core::{Document, Region, SerializableDynamicImage};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
 pub trait InpaintRegionExt {
     fn clamp(&self, width: u32, height: u32) -> Option<(u32, u32, u32, u32)>;
 }
 
-impl InpaintRegionExt for InpaintRegion {
+impl InpaintRegionExt for Region {
     fn clamp(&self, width: u32, height: u32) -> Option<(u32, u32, u32, u32)> {
         if width == 0 || height == 0 {
             return None;
@@ -27,7 +26,7 @@ impl InpaintRegionExt for InpaintRegion {
     }
 }
 
-pub(crate) fn encode_image(image: &SerializableDynamicImage, ext: &str) -> anyhow::Result<Vec<u8>> {
+pub fn encode_image(image: &SerializableDynamicImage, ext: &str) -> anyhow::Result<Vec<u8>> {
     let mut buf = Vec::new();
     let mut cursor = Cursor::new(&mut buf);
     let format = ImageFormat::from_extension(ext).unwrap_or(ImageFormat::Jpeg);
@@ -35,7 +34,7 @@ pub(crate) fn encode_image(image: &SerializableDynamicImage, ext: &str) -> anyho
     Ok(buf)
 }
 
-pub(crate) fn mime_from_ext(ext: &str) -> &'static str {
+pub fn mime_from_ext(ext: &str) -> &'static str {
     match ext {
         "png" => "image/png",
         "jpg" | "jpeg" => "image/jpeg",
@@ -44,11 +43,7 @@ pub(crate) fn mime_from_ext(ext: &str) -> &'static str {
     }
 }
 
-pub(crate) fn blank_rgba(
-    width: u32,
-    height: u32,
-    color: image::Rgba<u8>,
-) -> SerializableDynamicImage {
+pub fn blank_rgba(width: u32, height: u32, color: image::Rgba<u8>) -> SerializableDynamicImage {
     let blank = RgbaImage::from_pixel(width, height, color);
     image::DynamicImage::ImageRgba8(blank).into()
 }

koharu-core/src/commands.rs

@@ -1,4 +1,4 @@
-use crate::{TextBlock, TextShaderEffect, TextStrokeStyle};
+use crate::{TextShaderEffect, TextStrokeStyle};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -14,12 +14,6 @@ pub struct OpenExternalPayload {
     pub url: String,
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct IndexPayload {
-    pub index: usize,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ThumbnailResult {
@@ -53,81 +47,21 @@ pub struct FileResult {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct RenderPayload {
-    pub index: usize,
-    pub text_block_index: Option<usize>,
-    pub shader_effect: Option<TextShaderEffect>,
-    pub shader_stroke: Option<TextStrokeStyle>,
-    pub font_family: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateTextBlocksPayload {
-    pub index: usize,
-    pub text_blocks: Vec<TextBlock>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct LlmListPayload {
-    pub language: Option<String>,
-    pub openai_compatible_base_url: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ApiKeyGetPayload {
-    pub provider: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ApiKeySetPayload {
-    pub provider: String,
-    pub api_key: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ApiKeyResult {
-    pub api_key: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct LlmLoadPayload {
-    pub id: String,
-    pub api_key: Option<String>,
-    pub base_url: Option<String>,
-    pub temperature: Option<f64>,
-    pub max_tokens: Option<u32>,
-    pub custom_system_prompt: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct LlmGeneratePayload {
-    pub index: usize,
-    pub text_block_index: Option<usize>,
+pub struct LlmCatalogPayload {
     pub language: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct LlmLoadParams {
-    pub id: String,
-    pub api_key: Option<String>,
-    pub base_url: Option<String>,
-    pub temperature: Option<f64>,
-    pub max_tokens: Option<u32>,
-    pub custom_system_prompt: Option<String>,
+    pub target: crate::LlmTarget,
+    pub options: Option<crate::LlmGenerationOptions>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct LlmGenerateParams {
-    pub index: usize,
+    pub document_id: String,
     pub text_block_index: Option<usize>,
     pub language: Option<String>,
 }
@@ -135,57 +69,18 @@ pub struct LlmGenerateParams {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProcessRequest {
-    pub index: Option<usize>,
-    pub llm_model_id: Option<String>,
-    pub llm_api_key: Option<String>,
-    pub llm_base_url: Option<String>,
-    pub llm_temperature: Option<f64>,
-    pub llm_max_tokens: Option<u32>,
-    pub llm_custom_system_prompt: Option<String>,
+    pub document_id: Option<String>,
+    pub llm: Option<crate::PipelineLlmRequest>,
     pub language: Option<String>,
     pub shader_effect: Option<TextShaderEffect>,
     pub shader_stroke: Option<TextStrokeStyle>,
     pub font_family: Option<String>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct InpaintRegion {
-    pub x: u32,
-    pub y: u32,
-    pub width: u32,
-    pub height: u32,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateInpaintMaskPayload {
-    pub index: usize,
-    #[serde(with = "serde_bytes")]
-    pub mask: Vec<u8>,
-    pub region: Option<InpaintRegion>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateBrushLayerPayload {
-    pub index: usize,
-    #[serde(with = "serde_bytes")]
-    pub patch: Vec<u8>,
-    pub region: InpaintRegion,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct InpaintPartialPayload {
-    pub index: usize,
-    pub region: InpaintRegion,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ViewImageParams {
-    pub index: usize,
+    pub document_id: String,
     pub layer: String,
     pub max_size: Option<u32>,
 }
@@ -193,7 +88,7 @@ pub struct ViewImageParams {
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ViewTextBlockParams {
-    pub index: usize,
+    pub document_id: String,
     pub text_block_index: usize,
     pub layer: Option<String>,
 }
@@ -207,24 +102,30 @@ pub struct OpenDocumentsParams {
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ExportDocumentParams {
-    pub index: usize,
+    pub document_id: String,
     pub output_path: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct RenderParams {
-    pub index: usize,
+    pub document_id: String,
     pub text_block_index: Option<usize>,
     pub shader_effect: Option<String>,
     pub font_family: Option<String>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentIdParam {
+    pub document_id: String,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ProcessParams {
-    pub index: Option<usize>,
-    pub llm_model_id: Option<String>,
+    pub document_id: Option<String>,
+    pub llm_target: Option<crate::LlmTarget>,
     pub language: Option<String>,
     pub shader_effect: Option<String>,
     pub font_family: Option<String>,
@@ -273,7 +174,7 @@ pub struct MaskMorphPayload {
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct InpaintRegionParams {
-    pub index: usize,
+    pub document_id: String,
     pub x: u32,
     pub y: u32,
     pub width: u32,
@@ -282,7 +183,6 @@ pub struct InpaintRegionParams {
 
 #[cfg(test)]
 mod tests {
-    use crate::{TextAlign, TextStyle};
     use serde::Serialize;
     use serde::de::DeserializeOwned;
 
@@ -301,39 +201,13 @@ mod tests {
 
     #[test]
     fn command_dtos_round_trip() {
-        let text_block = TextBlock {
-            x: 10.0,
-            y: 11.0,
-            width: 120.0,
-            height: 40.0,
-            confidence: 0.95,
-            text: Some("source".to_string()),
-            translation: Some("translated".to_string()),
-            style: Some(TextStyle {
-                font_families: vec!["Noto Sans".to_string()],
-                font_size: Some(18.0),
-                color: [255, 255, 255, 255],
-                effect: Some(TextShaderEffect {
-                    italic: true,
-                    bold: false,
-                }),
-                stroke: Some(TextStrokeStyle {
-                    enabled: true,
-                    color: [255, 255, 255, 255],
-                    width_px: Some(2.0),
-                }),
-                text_align: Some(TextAlign::Right),
-            }),
-            ..Default::default()
-        };
-
         round_trip(&DeviceInfo {
             ml_device: "CPU".to_string(),
         });
         round_trip(&OpenExternalPayload {
             url: "https://example.com".to_string(),
         });
-        round_trip(&IndexPayload { index: 2 });
+
         round_trip(&ThumbnailResult {
             data: vec![1, 2, 3],
             content_type: "image/webp".to_string(),
@@ -353,62 +227,52 @@ mod tests {
             data: vec![1, 2, 3, 4],
             content_type: "image/png".to_string(),
         });
-        round_trip(&RenderPayload {
-            index: 1,
-            text_block_index: Some(3),
-            shader_effect: Some(TextShaderEffect {
-                italic: false,
-                bold: true,
-            }),
-            shader_stroke: Some(TextStrokeStyle {
-                enabled: true,
-                color: [255, 255, 255, 255],
-                width_px: Some(1.6),
-            }),
-            font_family: Some("Noto Sans".to_string()),
-        });
-        round_trip(&UpdateTextBlocksPayload {
-            index: 1,
-            text_blocks: vec![text_block.clone()],
-        });
-        round_trip(&LlmListPayload {
+        round_trip(&LlmCatalogPayload {
             language: Some("zh-CN".to_string()),
-            openai_compatible_base_url: Some("http://127.0.0.1:1234/v1".to_string()),
-        });
-        round_trip(&LlmLoadPayload {
-            id: "sakura".to_string(),
-            api_key: None,
-            base_url: Some("http://127.0.0.1:1234/v1".to_string()),
-            temperature: Some(0.1),
-            max_tokens: Some(1000),
-            custom_system_prompt: None,
         });
-        round_trip(&LlmGeneratePayload {
-            index: 1,
-            text_block_index: Some(0),
-            language: Some("zh-CN".to_string()),
+        round_trip(&crate::LlmLoadRequest {
+            target: crate::LlmTarget {
+                kind: crate::LlmTargetKind::Local,
+                model_id: "sakura".to_string(),
+                provider_id: None,
+            },
+            options: Some(crate::LlmGenerationOptions {
+                temperature: Some(0.1),
+                max_tokens: Some(1000),
+                custom_system_prompt: None,
+            }),
         });
         round_trip(&LlmLoadParams {
-            id: "sakura".to_string(),
-            api_key: None,
-            base_url: Some("http://127.0.0.1:1234/v1".to_string()),
-            temperature: None,
-            max_tokens: None,
-            custom_system_prompt: None,
+            target: crate::LlmTarget {
+                kind: crate::LlmTargetKind::Provider,
+                model_id: "gpt-5-mini".to_string(),
+                provider_id: Some("openai".to_string()),
+            },
+            options: Some(crate::LlmGenerationOptions {
+                temperature: None,
+                max_tokens: None,
+                custom_system_prompt: None,
+            }),
         });
         round_trip(&LlmGenerateParams {
-            index: 1,
+            document_id: "abc123".to_string(),
             text_block_index: Some(0),
             language: Some("zh-CN".to_string()),
         });
         round_trip(&ProcessRequest {
-            index: Some(1),
-            llm_model_id: Some("sakura".to_string()),
-            llm_api_key: None,
-            llm_base_url: Some("http://127.0.0.1:1234/v1".to_string()),
-            llm_temperature: Some(0.1),
-            llm_max_tokens: Some(1000),
-            llm_custom_system_prompt: Some("Translate manga".to_string()),
+            document_id: Some("abc123".to_string()),
+            llm: Some(crate::PipelineLlmRequest {
+                target: crate::LlmTarget {
+                    kind: crate::LlmTargetKind::Provider,
+                    model_id: "gpt-5-mini".to_string(),
+                    provider_id: Some("openai".to_string()),
+                },
+                options: Some(crate::LlmGenerationOptions {
+                    temperature: Some(0.1),
+                    max_tokens: Some(1000),
+                    custom_system_prompt: Some("Translate manga".to_string()),
+                }),
+            }),
             language: Some("zh-CN".to_string()),
             shader_effect: Some(TextShaderEffect {
                 italic: true,
@@ -421,48 +285,13 @@ mod tests {
             }),
             font_family: Some("Noto Sans".to_string()),
         });
-        round_trip(&InpaintRegion {
-            x: 10,
-            y: 20,
-            width: 30,
-            height: 40,
-        });
-        round_trip(&UpdateInpaintMaskPayload {
-            index: 1,
-            mask: vec![0, 255],
-            region: Some(InpaintRegion {
-                x: 1,
-                y: 2,
-                width: 3,
-                height: 4,
-            }),
-        });
-        round_trip(&UpdateBrushLayerPayload {
-            index: 1,
-            patch: vec![1, 2, 3],
-            region: InpaintRegion {
-                x: 4,
-                y: 5,
-                width: 6,
-                height: 7,
-            },
-        });
-        round_trip(&InpaintPartialPayload {
-            index: 1,
-            region: InpaintRegion {
-                x: 8,
-                y: 9,
-                width: 10,
-                height: 11,
-            },
-        });
         round_trip(&ViewImageParams {
-            index: 1,
+            document_id: "abc123".to_string(),
             layer: "original".to_string(),
             max_size: Some(512),
         });
         round_trip(&ViewTextBlockParams {
-            index: 1,
+            document_id: "abc123".to_string(),
             text_block_index: 0,
             layer: Some("rendered".to_string()),
         });
@@ -470,18 +299,22 @@ mod tests {
             paths: vec!["a.png".to_string(), "b.png".to_string()],
         });
         round_trip(&ExportDocumentParams {
-            index: 1,
+            document_id: "abc123".to_string(),
             output_path: "out.png".to_string(),
         });
         round_trip(&RenderParams {
-            index: 1,
+            document_id: "abc123".to_string(),
             text_block_index: Some(0),
             shader_effect: Some("bold".to_string()),
             font_family: Some("Noto Sans".to_string()),
         });
         round_trip(&ProcessParams {
-            index: Some(1),
-            llm_model_id: Some("sakura".to_string()),
+            document_id: Some("abc123".to_string()),
+            llm_target: Some(crate::LlmTarget {
+                kind: crate::LlmTargetKind::Local,
+                model_id: "sakura".to_string(),
+                provider_id: None,
+            }),
             language: Some("zh-CN".to_string()),
             shader_effect: Some("italic,bold".to_string()),
             font_family: Some("Noto Sans".to_string()),
@@ -515,7 +348,7 @@ mod tests {
             radius: 2,
         });
         round_trip(&InpaintRegionParams {
-            index: 1,
+            document_id: "abc123".to_string(),
             x: 2,
             y: 3,
             width: 4,

koharu-core/src/lib.rs

@@ -15,12 +15,11 @@ pub use font::{FontPrediction, NamedFontPrediction, TextDirection};
 pub use image::SerializableDynamicImage;
 pub use protocol::*;
 
-use std::{path::PathBuf, sync::Arc};
+use std::path::PathBuf;
 
 use ::image::GenericImageView;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use tokio::sync::RwLock;
 use utoipa::ToSchema;
 use uuid::Uuid;
 
@@ -63,12 +62,6 @@ pub struct TextBlock {
 }
 
 impl TextBlock {
-    pub fn ensure_id(&mut self) {
-        if self.id.trim().is_empty() {
-            self.id = new_text_block_id();
-        }
-    }
-
     pub fn set_layout_seed(&mut self, x: f32, y: f32, width: f32, height: f32) {
         self.layout_seed_x = Some(x);
         self.layout_seed_y = Some(y);
@@ -125,7 +118,9 @@ const fn default_stroke_color() -> [u8; 4] {
     [255, 255, 255, 255]
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default, ToSchema, JsonSchema)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default, ToSchema, JsonSchema,
+)]
 #[serde(rename_all = "camelCase")]
 pub enum TextAlign {
     #[default]
@@ -155,8 +150,6 @@ pub struct Document {
     pub image: SerializableDynamicImage,
     pub width: u32,
     pub height: u32,
-    #[serde(default)]
-    pub revision: u64,
     pub text_blocks: Vec<TextBlock>,
     pub segment: Option<SerializableDynamicImage>,
     pub inpainted: Option<SerializableDynamicImage>,
@@ -199,29 +192,10 @@ impl Document {
             ..Default::default()
         })
     }
-
-    pub fn ensure_text_block_ids(&mut self) {
-        for block in &mut self.text_blocks {
-            block.ensure_id();
-        }
-    }
-
-    pub fn bump_revision(&mut self) {
-        self.revision = self.revision.saturating_add(1);
-    }
-
-    pub fn prepare_for_store(&mut self) {
-        self.ensure_text_block_ids();
-    }
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
-pub struct State {
-    pub documents: Vec<Document>,
-}
-
-pub type AppState = Arc<RwLock<State>>;
-
+/// Lightweight entry for a page — no decoded image data.
+/// Stored in global state; the full `Document` lives in the page cache.
 #[cfg(test)]
 mod tests {
     use super::TextBlock;

koharu-core/src/protocol.rs

@@ -2,9 +2,11 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
-use crate::{Document, FontPrediction, TextBlock, TextShaderEffect, TextStrokeStyle, TextStyle};
+use crate::{FontPrediction, TextBlock, TextShaderEffect, TextStrokeStyle, TextStyle};
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, JsonSchema, ToSchema)]
+#[derive(
+    Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, JsonSchema, ToSchema,
+)]
 #[serde(rename_all = "camelCase")]
 pub struct FontFaceInfo {
     pub family_name: String,
@@ -20,22 +22,62 @@ pub struct MetaInfo {
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct BootstrapConfig {
-    pub runtime: BootstrapPathConfig,
-    pub models: BootstrapPathConfig,
-    pub http: BootstrapHttpConfig,
+pub struct AppConfig {
+    pub data: AppDataConfig,
+    #[serde(default)]
+    pub llm: AppLlmConfig,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct BootstrapPathConfig {
+pub struct AppConfigUpdate {
+    pub data: AppDataConfigUpdate,
+    #[serde(default)]
+    pub llm: AppLlmConfigUpdate,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct AppDataConfig {
     pub path: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct BootstrapHttpConfig {
-    pub proxy: Option<String>,
+pub struct AppDataConfigUpdate {
+    pub path: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct AppLlmConfig {
+    #[serde(default)]
+    pub providers: Vec<AppLlmProviderConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct AppLlmConfigUpdate {
+    #[serde(default)]
+    pub providers: Vec<AppLlmProviderConfigUpdate>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct AppLlmProviderConfig {
+    pub id: String,
+    pub base_url: Option<String>,
+    pub has_api_key: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct AppLlmProviderConfigUpdate {
+    pub id: String,
+    pub base_url: Option<String>,
+    pub api_key: Option<String>,
+    #[serde(default)]
+    pub clear_api_key: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
@@ -45,7 +87,6 @@ pub struct DocumentSummary {
     pub name: String,
     pub width: u32,
     pub height: u32,
-    pub revision: u64,
     pub has_segment: bool,
     pub has_inpainted: bool,
     pub has_brush_layer: bool,
@@ -53,23 +94,6 @@ pub struct DocumentSummary {
     pub text_block_count: usize,
 }
 
-impl From<&Document> for DocumentSummary {
-    fn from(document: &Document) -> Self {
-        Self {
-            id: document.id.clone(),
-            name: document.name.clone(),
-            width: document.width,
-            height: document.height,
-            revision: document.revision,
-            has_segment: document.segment.is_some(),
-            has_inpainted: document.inpainted.is_some(),
-            has_brush_layer: document.brush_layer.is_some(),
-            has_rendered: document.rendered.is_some(),
-            text_block_count: document.text_blocks.len(),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct TextBlockDetail {
@@ -124,7 +148,6 @@ pub struct DocumentDetail {
     pub name: String,
     pub width: u32,
     pub height: u32,
-    pub revision: u64,
     pub text_blocks: Vec<TextBlockDetail>,
     #[schema(value_type = Vec<u8>)]
     pub image: serde_bytes::ByteBuf,
@@ -142,7 +165,6 @@ pub struct DocumentDetail {
     pub rendered: Option<serde_bytes::ByteBuf>,
 }
 
-
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct TextBlockInput {
@@ -204,14 +226,6 @@ pub struct ExportResult {
     pub count: usize,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct LlmModelInfo {
-    pub id: String,
-    pub languages: Vec<String>,
-    pub source: String,
-}
-
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema, ToSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum LlmStateStatus {
@@ -225,36 +239,76 @@ pub enum LlmStateStatus {
 #[serde(rename_all = "camelCase")]
 pub struct LlmState {
     pub status: LlmStateStatus,
-    pub model_id: Option<String>,
-    pub source: Option<String>,
+    pub target: Option<LlmTarget>,
     pub error: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct LlmLoadRequest {
-    pub id: String,
-    pub api_key: Option<String>,
-    pub base_url: Option<String>,
+pub struct LlmGenerationOptions {
     pub temperature: Option<f64>,
     pub max_tokens: Option<u32>,
     pub custom_system_prompt: Option<String>,
 }
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema, ToSchema, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum LlmTargetKind {
+    Local,
+    Provider,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct LlmTarget {
+    pub kind: LlmTargetKind,
+    pub model_id: String,
+    pub provider_id: Option<String>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct LlmPingRequest {
-    pub base_url: String,
-    pub api_key: Option<String>,
+pub struct LlmLoadRequest {
+    pub target: LlmTarget,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub options: Option<LlmGenerationOptions>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct LlmCatalogModel {
+    pub target: LlmTarget,
+    pub name: String,
+    pub languages: Vec<String>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum LlmProviderCatalogStatus {
+    Ready,
+    MissingConfiguration,
+    DiscoveryFailed,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct LlmPingResponse {
-    pub ok: bool,
-    pub models: Vec<String>,
-    pub latency_ms: Option<u64>,
+pub struct LlmProviderCatalog {
+    pub id: String,
+    pub name: String,
+    pub requires_api_key: bool,
+    pub requires_base_url: bool,
+    pub has_api_key: bool,
+    pub base_url: Option<String>,
+    pub status: LlmProviderCatalogStatus,
     pub error: Option<String>,
+    pub models: Vec<LlmCatalogModel>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct LlmCatalog {
+    pub local_models: Vec<LlmCatalogModel>,
+    pub providers: Vec<LlmProviderCatalog>,
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema, ToSchema)]
@@ -320,22 +374,9 @@ pub struct DocumentsChangedEvent {
 #[serde(rename_all = "camelCase")]
 pub struct DocumentChangedEvent {
     pub document_id: String,
-    pub revision: u64,
     pub changed: Vec<String>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ApiKeyValue {
-    pub api_key: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ApiKeyResponse {
-    pub api_key: Option<String>,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct RenderRequest {
@@ -352,16 +393,19 @@ pub struct TranslateRequest {
     pub language: Option<String>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct PipelineLlmRequest {
+    pub target: LlmTarget,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub options: Option<LlmGenerationOptions>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct PipelineJobRequest {
     pub document_id: Option<String>,
-    pub llm_model_id: Option<String>,
-    pub llm_api_key: Option<String>,
-    pub llm_base_url: Option<String>,
-    pub llm_temperature: Option<f64>,
-    pub llm_max_tokens: Option<u32>,
-    pub llm_custom_system_prompt: Option<String>,
+    pub llm: Option<PipelineLlmRequest>,
     pub language: Option<String>,
     pub shader_effect: Option<TextShaderEffect>,
     pub shader_stroke: Option<TextStrokeStyle>,

koharu-llm/src/api.rs

@@ -1,60 +0,0 @@
-pub struct ApiModelInfo {
-    pub id: &'static str,
-    pub name: &'static str,
-}
-
-pub struct ApiProviderInfo {
-    pub id: &'static str,
-    pub name: &'static str,
-    pub models: &'static [ApiModelInfo],
-}
-
-pub const OPENAI_COMPATIBLE_ID: &str = "openai-compatible";
-
-pub const OPENAI: ApiProviderInfo = ApiProviderInfo {
-    id: "openai",
-    name: "OpenAI",
-    models: &[ApiModelInfo {
-        id: "gpt-5-mini",
-        name: "GPT-5 mini",
-    }],
-};
-
-pub const GEMINI: ApiProviderInfo = ApiProviderInfo {
-    id: "gemini",
-    name: "Gemini",
-    models: &[ApiModelInfo {
-        id: "gemini-3.1-flash-lite-preview",
-        name: "Gemini 3.1 Flash-Lite Preview",
-    }],
-};
-
-pub const CLAUDE: ApiProviderInfo = ApiProviderInfo {
-    id: "claude",
-    name: "Claude",
-    models: &[ApiModelInfo {
-        id: "claude-haiku-4-5",
-        name: "Claude Haiku 4.5",
-    }],
-};
-
-pub const DEEPSEEK: ApiProviderInfo = ApiProviderInfo {
-    id: "deepseek",
-    name: "DeepSeek",
-    models: &[ApiModelInfo {
-        id: "deepseek-chat",
-        name: "DeepSeek-V3.2-Chat",
-    }],
-};
-
-pub const ALL_API_PROVIDERS: &[&ApiProviderInfo] = &[&OPENAI, &GEMINI, &CLAUDE, &DEEPSEEK];
-
-pub fn find_api_model(id: &str) -> Option<(&'static ApiProviderInfo, &'static str)> {
-    let (provider_id, model_id) = id.split_once(':')?;
-    let provider = ALL_API_PROVIDERS
-        .iter()
-        .copied()
-        .find(|p| p.id == provider_id)?;
-    let model = provider.models.iter().find(|m| m.id == model_id)?;
-    Some((provider, model.id))
-}

koharu-llm/src/lib.rs

@@ -1,4 +1,3 @@
-pub mod api;
 pub mod language;
 mod model;
 pub mod paddleocr_vl;

koharu-llm/src/providers/chat_completions.rs

@@ -0,0 +1,80 @@
+use std::sync::Arc;
+
+use reqwest_middleware::ClientWithMiddleware;
+use serde::Serialize;
+
+use super::ensure_provider_success;
+
+pub enum ChatCompletionsAuth {
+    None,
+    Bearer(String),
+}
+
+pub struct ChatCompletionsRequest {
+    pub provider: &'static str,
+    pub endpoint: String,
+    pub auth: ChatCompletionsAuth,
+    pub model: String,
+    pub system_prompt: String,
+    pub user_prompt: String,
+    pub temperature: Option<f64>,
+    pub max_tokens: Option<u32>,
+}
+
+#[derive(Serialize)]
+struct ChatMessage {
+    role: &'static str,
+    content: String,
+}
+
+#[derive(Serialize)]
+struct ChatRequest<'a> {
+    model: &'a str,
+    messages: Vec<ChatMessage>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    temperature: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    max_tokens: Option<u32>,
+}
+
+pub async fn send_chat_completion(
+    http_client: Arc<ClientWithMiddleware>,
+    request: ChatCompletionsRequest,
+) -> anyhow::Result<String> {
+    let body = ChatRequest {
+        model: &request.model,
+        messages: vec![
+            ChatMessage {
+                role: "system",
+                content: request.system_prompt,
+            },
+            ChatMessage {
+                role: "user",
+                content: request.user_prompt,
+            },
+        ],
+        temperature: request.temperature,
+        max_tokens: request.max_tokens,
+    };
+
+    let mut http_request = http_client.post(&request.endpoint);
+    if let ChatCompletionsAuth::Bearer(api_key) = request.auth {
+        http_request = http_request.bearer_auth(api_key);
+    }
+
+    let response = http_request
+        .header("content-type", "application/json")
+        .body(serde_json::to_vec(&body)?)
+        .send()
+        .await?;
+
+    let resp: serde_json::Value = ensure_provider_success(request.provider, response)
+        .await?
+        .json()
+        .await?;
+
+    resp["choices"][0]["message"]["content"]
+        .as_str()
+        .map(ToOwned::to_owned)
+        .ok_or_else(|| anyhow::anyhow!("{} returned no content", request.provider))
+}

koharu-llm/src/providers/deepseek.rs

@@ -3,30 +3,17 @@ use std::pin::Pin;
 use std::sync::Arc;
 
 use reqwest_middleware::ClientWithMiddleware;
-use serde::Serialize;
 
 use crate::{Language, prompt::system_prompt};
 
-use super::{AnyProvider, ensure_provider_success};
+use super::AnyProvider;
+use super::chat_completions::{ChatCompletionsAuth, ChatCompletionsRequest, send_chat_completion};
 
 pub struct DeepSeekProvider {
     pub http_client: Arc<ClientWithMiddleware>,
     pub api_key: String,
 }
 
-#[derive(Serialize)]
-struct ChatMessage {
-    role: &'static str,
-    content: String,
-}
-
-#[derive(Serialize)]
-struct ChatRequest<'a> {
-    model: &'a str,
-    messages: Vec<ChatMessage>,
-    temperature: f32,
-}
-
 impl AnyProvider for DeepSeekProvider {
     fn translate<'a>(
         &'a self,
@@ -35,41 +22,20 @@ impl AnyProvider for DeepSeekProvider {
         model: &'a str,
     ) -> Pin<Box<dyn Future<Output = anyhow::Result<String>> + Send + 'a>> {
         Box::pin(async move {
-            let body = ChatRequest {
-                model,
-                messages: vec![
-                    ChatMessage {
-                        role: "system",
-                        content: system_prompt(target_language),
-                    },
-                    ChatMessage {
-                        role: "user",
-                        content: source.to_string(),
-                    },
-                ],
-                temperature: 1.3,
-            };
-
-            let response = self
-                .http_client
-                .post("https://api.deepseek.com/chat/completions")
-                .bearer_auth(&self.api_key)
-                .header("content-type", "application/json")
-                .body(serde_json::to_vec(&body)?)
-                .send()
-                .await?;
-
-            let resp: serde_json::Value = ensure_provider_success("deepseek", response)
-                .await?
-                .json()
-                .await?;
-
-            let text = resp["choices"][0]["message"]["content"]
-                .as_str()
-                .ok_or_else(|| anyhow::anyhow!("DeepSeek returned no content"))?
-                .to_string();
-
-            Ok(text)
+            send_chat_completion(
+                Arc::clone(&self.http_client),
+                ChatCompletionsRequest {
+                    provider: "deepseek",
+                    endpoint: "https://api.deepseek.com/chat/completions".to_string(),
+                    auth: ChatCompletionsAuth::Bearer(self.api_key.clone()),
+                    model: model.to_string(),
+                    system_prompt: system_prompt(target_language),
+                    user_prompt: source.to_string(),
+                    temperature: Some(1.3),
+                    max_tokens: None,
+                },
+            )
+            .await
         })
     }
 }

koharu-llm/src/providers/mod.rs

@@ -9,6 +9,7 @@ use reqwest_middleware::ClientWithMiddleware;
 
 use crate::Language;
 
+mod chat_completions;
 pub mod claude;
 pub mod deepseek;
 pub mod gemini;
@@ -16,9 +17,39 @@ pub mod openai;
 pub mod openai_compatible;
 
 const API_KEY_SERVICE: &str = "koharu";
+pub const OPENAI_COMPATIBLE_ID: &str = "openai-compatible";
 
 static NO_KEYRING: AtomicBool = AtomicBool::new(false);
 
+#[derive(Debug, Clone, Copy)]
+pub struct ProviderModelDescriptor {
+    pub id: &'static str,
+    pub name: &'static str,
+}
+
+#[derive(Debug, Clone)]
+pub struct DiscoveredProviderModel {
+    pub id: String,
+    pub name: String,
+}
+
+pub type ProviderDiscoveryFuture =
+    Pin<Box<dyn Future<Output = anyhow::Result<Vec<DiscoveredProviderModel>>> + Send>>;
+
+pub enum ProviderCatalogModels {
+    Static(&'static [ProviderModelDescriptor]),
+    Dynamic(fn(ProviderConfig) -> ProviderDiscoveryFuture),
+}
+
+pub struct ProviderDescriptor {
+    pub id: &'static str,
+    pub name: &'static str,
+    pub requires_api_key: bool,
+    pub requires_base_url: bool,
+    pub models: ProviderCatalogModels,
+    pub build: fn(ProviderConfig) -> anyhow::Result<Box<dyn AnyProvider>>,
+}
+
 pub fn disable_keyring() {
     NO_KEYRING.store(true, Ordering::Relaxed);
 }
@@ -112,6 +143,7 @@ pub trait AnyProvider: Send + Sync {
     ) -> Pin<Box<dyn Future<Output = anyhow::Result<String>> + Send + 'a>>;
 }
 
+#[derive(Clone)]
 pub struct ProviderConfig {
     pub http_client: Arc<ClientWithMiddleware>,
     pub api_key: Option<String>,
@@ -121,50 +153,204 @@ pub struct ProviderConfig {
     pub custom_system_prompt: Option<String>,
 }
 
+const OPENAI_MODELS: &[ProviderModelDescriptor] = &[ProviderModelDescriptor {
+    id: "gpt-5-mini",
+    name: "GPT-5 mini",
+}];
+
+const GEMINI_MODELS: &[ProviderModelDescriptor] = &[ProviderModelDescriptor {
+    id: "gemini-3.1-flash-lite-preview",
+    name: "Gemini 3.1 Flash-Lite Preview",
+}];
+
+const CLAUDE_MODELS: &[ProviderModelDescriptor] = &[ProviderModelDescriptor {
+    id: "claude-haiku-4-5",
+    name: "Claude Haiku 4.5",
+}];
+
+const DEEPSEEK_MODELS: &[ProviderModelDescriptor] = &[ProviderModelDescriptor {
+    id: "deepseek-chat",
+    name: "DeepSeek-V3.2-Chat",
+}];
+
+const PROVIDERS: &[ProviderDescriptor] = &[
+    ProviderDescriptor {
+        id: "openai",
+        name: "OpenAI",
+        requires_api_key: true,
+        requires_base_url: false,
+        models: ProviderCatalogModels::Static(OPENAI_MODELS),
+        build: build_openai_provider,
+    },
+    ProviderDescriptor {
+        id: "gemini",
+        name: "Gemini",
+        requires_api_key: true,
+        requires_base_url: false,
+        models: ProviderCatalogModels::Static(GEMINI_MODELS),
+        build: build_gemini_provider,
+    },
+    ProviderDescriptor {
+        id: "claude",
+        name: "Claude",
+        requires_api_key: true,
+        requires_base_url: false,
+        models: ProviderCatalogModels::Static(CLAUDE_MODELS),
+        build: build_claude_provider,
+    },
+    ProviderDescriptor {
+        id: "deepseek",
+        name: "DeepSeek",
+        requires_api_key: true,
+        requires_base_url: false,
+        models: ProviderCatalogModels::Static(DEEPSEEK_MODELS),
+        build: build_deepseek_provider,
+    },
+    ProviderDescriptor {
+        id: OPENAI_COMPATIBLE_ID,
+        name: "OpenAI-compatible",
+        requires_api_key: false,
+        requires_base_url: true,
+        models: ProviderCatalogModels::Dynamic(discover_openai_compatible_models),
+        build: build_openai_compatible_provider,
+    },
+];
+
+pub fn all_provider_descriptors() -> &'static [ProviderDescriptor] {
+    PROVIDERS
+}
+
+pub fn find_provider_descriptor(provider_id: &str) -> Option<&'static ProviderDescriptor> {
+    PROVIDERS
+        .iter()
+        .find(|descriptor| descriptor.id == provider_id)
+}
+
+pub fn discover_models(
+    provider_id: &str,
+    config: ProviderConfig,
+) -> anyhow::Result<ProviderDiscoveryFuture> {
+    let descriptor = find_provider_descriptor(provider_id)
+        .ok_or_else(|| anyhow::anyhow!("Unknown API provider: {provider_id}"))?;
+    Ok(match descriptor.models {
+        ProviderCatalogModels::Static(models) => {
+            let models = models
+                .iter()
+                .map(|model| DiscoveredProviderModel {
+                    id: model.id.to_string(),
+                    name: model.name.to_string(),
+                })
+                .collect::<Vec<_>>();
+            Box::pin(async move { Ok(models) })
+        }
+        ProviderCatalogModels::Dynamic(discover) => discover(config),
+    })
+}
+
 pub fn build_provider(
     provider_id: &str,
     config: ProviderConfig,
 ) -> anyhow::Result<Box<dyn AnyProvider>> {
-    let required_api_key = |name: &str| {
-        config
+    let descriptor = find_provider_descriptor(provider_id)
+        .ok_or_else(|| anyhow::anyhow!("Unknown API provider: {provider_id}"))?;
+
+    if descriptor.requires_api_key
+        && config
             .api_key
-            .clone()
-            .filter(|value| !value.trim().is_empty())
-            .ok_or_else(|| anyhow::anyhow!("api_key is required for {name}"))
-    };
-
-    let provider: Box<dyn AnyProvider> = match provider_id {
-        "openai" => Box::new(openai::OpenAiProvider {
-            http_client: Arc::clone(&config.http_client),
-            api_key: required_api_key("openai")?,
-        }),
-        "gemini" => Box::new(gemini::GeminiProvider {
-            http_client: Arc::clone(&config.http_client),
-            api_key: required_api_key("gemini")?,
-        }),
-        "claude" => Box::new(claude::ClaudeProvider {
-            http_client: Arc::clone(&config.http_client),
-            api_key: required_api_key("claude")?,
-        }),
-        "deepseek" => Box::new(deepseek::DeepSeekProvider {
-            http_client: Arc::clone(&config.http_client),
-            api_key: required_api_key("deepseek")?,
-        }),
-        "openai-compatible" => Box::new(openai_compatible::OpenAiCompatibleProvider {
-            http_client: Arc::clone(&config.http_client),
-            base_url: config
-                .base_url
-                .filter(|value| !value.trim().is_empty())
-                .ok_or_else(|| {
-                    anyhow::anyhow!("base_url is required for the openai-compatible provider")
-                })?,
-            api_key: config.api_key,
-            temperature: config.temperature,
-            max_tokens: config.max_tokens,
-            custom_system_prompt: config.custom_system_prompt,
-        }),
-        other => anyhow::bail!("Unknown API provider: {other}"),
-    };
-
-    Ok(provider)
+            .as_deref()
+            .is_none_or(|value| value.trim().is_empty())
+    {
+        anyhow::bail!("api_key is required for {}", descriptor.id);
+    }
+
+    if descriptor.requires_base_url
+        && config
+            .base_url
+            .as_deref()
+            .is_none_or(|value| value.trim().is_empty())
+    {
+        anyhow::bail!("base_url is required for {}", descriptor.id);
+    }
+
+    (descriptor.build)(config)
+}
+
+fn required_api_key(config: &ProviderConfig, provider_id: &str) -> anyhow::Result<String> {
+    config
+        .api_key
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+        .ok_or_else(|| anyhow::anyhow!("api_key is required for {provider_id}"))
+}
+
+fn required_base_url(config: &ProviderConfig, provider_id: &str) -> anyhow::Result<String> {
+    config
+        .base_url
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+        .ok_or_else(|| anyhow::anyhow!("base_url is required for {provider_id}"))
+}
+
+fn build_openai_provider(config: ProviderConfig) -> anyhow::Result<Box<dyn AnyProvider>> {
+    Ok(Box::new(openai::OpenAiProvider {
+        http_client: Arc::clone(&config.http_client),
+        api_key: required_api_key(&config, "openai")?,
+    }))
+}
+
+fn build_gemini_provider(config: ProviderConfig) -> anyhow::Result<Box<dyn AnyProvider>> {
+    Ok(Box::new(gemini::GeminiProvider {
+        http_client: Arc::clone(&config.http_client),
+        api_key: required_api_key(&config, "gemini")?,
+    }))
+}
+
+fn build_claude_provider(config: ProviderConfig) -> anyhow::Result<Box<dyn AnyProvider>> {
+    Ok(Box::new(claude::ClaudeProvider {
+        http_client: Arc::clone(&config.http_client),
+        api_key: required_api_key(&config, "claude")?,
+    }))
+}
+
+fn build_deepseek_provider(config: ProviderConfig) -> anyhow::Result<Box<dyn AnyProvider>> {
+    Ok(Box::new(deepseek::DeepSeekProvider {
+        http_client: Arc::clone(&config.http_client),
+        api_key: required_api_key(&config, "deepseek")?,
+    }))
+}
+
+fn build_openai_compatible_provider(
+    config: ProviderConfig,
+) -> anyhow::Result<Box<dyn AnyProvider>> {
+    Ok(Box::new(openai_compatible::OpenAiCompatibleProvider {
+        http_client: Arc::clone(&config.http_client),
+        base_url: required_base_url(&config, OPENAI_COMPATIBLE_ID)?,
+        api_key: config.api_key,
+        temperature: config.temperature,
+        max_tokens: config.max_tokens,
+        custom_system_prompt: config.custom_system_prompt,
+    }))
+}
+
+fn discover_openai_compatible_models(config: ProviderConfig) -> ProviderDiscoveryFuture {
+    Box::pin(async move {
+        let base_url = required_base_url(&config, OPENAI_COMPATIBLE_ID)?;
+        let models = openai_compatible::list_models(
+            config.http_client,
+            &base_url,
+            config.api_key.as_deref(),
+        )
+        .await?;
+        Ok(models
+            .into_iter()
+            .map(|id| DiscoveredProviderModel {
+                name: id.clone(),
+                id,
+            })
+            .collect())
+    })
 }

koharu-llm/src/providers/openai.rs

@@ -3,29 +3,17 @@ use std::pin::Pin;
 use std::sync::Arc;
 
 use reqwest_middleware::ClientWithMiddleware;
-use serde::Serialize;
 
 use crate::{Language, prompt::system_prompt};
 
-use super::{AnyProvider, ensure_provider_success};
+use super::AnyProvider;
+use super::chat_completions::{ChatCompletionsAuth, ChatCompletionsRequest, send_chat_completion};
 
 pub struct OpenAiProvider {
     pub http_client: Arc<ClientWithMiddleware>,
     pub api_key: String,
 }
 
-#[derive(Serialize)]
-struct ChatMessage {
-    role: &'static str,
-    content: String,
-}
-
-#[derive(Serialize)]
-struct ChatRequest<'a> {
-    model: &'a str,
-    messages: Vec<ChatMessage>,
-}
-
 impl AnyProvider for OpenAiProvider {
     fn translate<'a>(
         &'a self,
@@ -34,40 +22,20 @@ impl AnyProvider for OpenAiProvider {
         model: &'a str,
     ) -> Pin<Box<dyn Future<Output = anyhow::Result<String>> + Send + 'a>> {
         Box::pin(async move {
-            let body = ChatRequest {
-                model,
-                messages: vec![
-                    ChatMessage {
-                        role: "system",
-                        content: system_prompt(target_language),
-                    },
-                    ChatMessage {
-                        role: "user",
-                        content: source.to_string(),
-                    },
-                ],
-            };
-
-            let response = self
-                .http_client
-                .post("https://api.openai.com/v1/chat/completions")
-                .bearer_auth(&self.api_key)
-                .header("content-type", "application/json")
-                .body(serde_json::to_vec(&body)?)
-                .send()
-                .await?;
-
-            let resp: serde_json::Value = ensure_provider_success("openai", response)
-                .await?
-                .json()
-                .await?;
-
-            let text = resp["choices"][0]["message"]["content"]
-                .as_str()
-                .ok_or_else(|| anyhow::anyhow!("OpenAI returned no content"))?
-                .to_string();
-
-            Ok(text)
+            send_chat_completion(
+                Arc::clone(&self.http_client),
+                ChatCompletionsRequest {
+                    provider: "openai",
+                    endpoint: "https://api.openai.com/v1/chat/completions".to_string(),
+                    auth: ChatCompletionsAuth::Bearer(self.api_key.clone()),
+                    model: model.to_string(),
+                    system_prompt: system_prompt(target_language),
+                    user_prompt: source.to_string(),
+                    temperature: None,
+                    max_tokens: None,
+                },
+            )
+            .await
         })
     }
 }

koharu-llm/src/providers/openai_compatible.rs

@@ -1,13 +1,12 @@
+use reqwest_middleware::ClientWithMiddleware;
+use serde::Deserialize;
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
-use std::time::Instant;
-
-use reqwest_middleware::ClientWithMiddleware;
-use serde::{Deserialize, Serialize};
 
 use crate::{Language, prompt::system_prompt};
 
+use super::chat_completions::{ChatCompletionsAuth, ChatCompletionsRequest, send_chat_completion};
 use super::{AnyProvider, ensure_provider_success};
 
 #[derive(Debug, Clone)]
@@ -30,22 +29,6 @@ struct ModelEntry {
     id: String,
 }
 
-#[derive(Serialize)]
-struct ChatMessage {
-    role: &'static str,
-    content: String,
-}
-
-#[derive(Serialize)]
-struct ChatRequest<'a> {
-    model: &'a str,
-    messages: Vec<ChatMessage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-}
-
 fn normalized_base_url(base_url: &str) -> anyhow::Result<String> {
     let normalized = base_url.trim().trim_end_matches('/').to_string();
     if normalized.is_empty() {
@@ -83,27 +66,6 @@ pub async fn list_models(
     Ok(ids)
 }
 
-pub struct PingResult {
-    pub models: Vec<String>,
-    pub latency_ms: u64,
-}
-
-pub async fn ping(
-    http_client: Arc<ClientWithMiddleware>,
-    base_url: &str,
-    api_key: Option<&str>,
-) -> anyhow::Result<PingResult> {
-    let start = Instant::now();
-    let models = tokio::time::timeout(
-        std::time::Duration::from_secs(5),
-        list_models(http_client, base_url, api_key),
-    )
-    .await
-    .map_err(|_| anyhow::anyhow!("Connection timed out after 5 seconds"))??;
-    let latency_ms = start.elapsed().as_millis() as u64;
-    Ok(PingResult { models, latency_ms })
-}
-
 impl AnyProvider for OpenAiCompatibleProvider {
     fn translate<'a>(
         &'a self,
@@ -116,49 +78,25 @@ impl AnyProvider for OpenAiCompatibleProvider {
                 Some(p) if !p.trim().is_empty() => p.clone(),
                 _ => system_prompt(target_language),
             };
-            let body = ChatRequest {
-                model,
-                messages: vec![
-                    ChatMessage {
-                        role: "system",
-                        content: prompt,
-                    },
-                    ChatMessage {
-                        role: "user",
-                        content: source.to_string(),
-                    },
-                ],
-                temperature: self.temperature,
-                max_tokens: self.max_tokens,
-            };
-
-            let endpoint = format!("{}/chat/completions", normalized_base_url(&self.base_url)?);
-            let mut request = self.http_client.post(endpoint);
-            if let Some(api_key) = self
-                .api_key
-                .as_deref()
-                .filter(|value| !value.trim().is_empty())
-            {
-                request = request.bearer_auth(api_key);
-            }
-
-            let response = request
-                .header("content-type", "application/json")
-                .body(serde_json::to_vec(&body)?)
-                .send()
-                .await?;
-
-            let resp: serde_json::Value = ensure_provider_success("openai-compatible", response)
-                .await?
-                .json()
-                .await?;
-
-            let text = resp["choices"][0]["message"]["content"]
-                .as_str()
-                .ok_or_else(|| anyhow::anyhow!("OpenAI-compatible provider returned no content"))?
-                .to_string();
-
-            Ok(text)
+            send_chat_completion(
+                Arc::clone(&self.http_client),
+                ChatCompletionsRequest {
+                    provider: "openai-compatible",
+                    endpoint: format!("{}/chat/completions", normalized_base_url(&self.base_url)?),
+                    auth: self
+                        .api_key
+                        .as_deref()
+                        .filter(|value| !value.trim().is_empty())
+                        .map(|key| ChatCompletionsAuth::Bearer(key.to_string()))
+                        .unwrap_or(ChatCompletionsAuth::None),
+                    model: model.to_string(),
+                    system_prompt: prompt,
+                    user_prompt: source.to_string(),
+                    temperature: self.temperature,
+                    max_tokens: self.max_tokens,
+                },
+            )
+            .await
         })
     }
 }

koharu-llm/tests/llm.rs

@@ -1,11 +1,12 @@
-use std::path::PathBuf;
 use std::sync::Arc;
 
 use strum::IntoEnumIterator;
 
 use koharu_llm::safe::llama_backend::LlamaBackend;
 use koharu_llm::{GenerateOptions, Language, Llm, ModelId};
-use koharu_runtime::{ComputePolicy, RuntimeManager, Settings};
+use koharu_runtime::{
+    ComputePolicy, DirectorySetting, RuntimeManager, Settings, default_app_data_root,
+};
 
 #[tokio::test]
 #[ignore] // Ignored because it requires downloading multiple large models.
@@ -14,13 +15,17 @@ async fn llm_generates_text_for_all_models() -> anyhow::Result<()> {
 テストです。
 さよなら。"#;
 
-    let model_dir = dirs::data_local_dir()
-        .map(|path| path.join("Koharu"))
-        .unwrap_or(PathBuf::from("."))
-        .join("models");
+    let app_data_root = default_app_data_root();
 
     let runtime = RuntimeManager::new(
-        Settings::from_paths(koharu_runtime::default_runtime_root(), model_dir),
+        Settings {
+            runtime: DirectorySetting {
+                path: app_data_root.join("runtime"),
+            },
+            models: DirectorySetting {
+                path: app_data_root.join("models"),
+            },
+        },
         ComputePolicy::PreferGpu,
     )?;
     runtime.prepare().await?;

koharu-psd/examples/full_fixture.rs

@@ -80,7 +80,6 @@ fn build_document() -> Document {
         image: to_serializable_rgba(original),
         width,
         height,
-        revision: 0,
         text_blocks: vec![
             TextBlock {
                 id: "hero-title".to_string(),

koharu-psd/tests/export.rs

@@ -31,7 +31,6 @@ fn sample_document() -> Document {
         image: rgba_image(16, 12, [240, 240, 240, 255]),
         width: 16,
         height: 12,
-        revision: 0,
         text_blocks: vec![
             TextBlock {
                 id: "block-h".to_string(),

koharu-rpc/src/api.rs

@@ -1,6 +1,3 @@
-use std::io::Cursor;
-
-use anyhow::Context;
 use axum::{
     Json,
     body::Body,
@@ -11,27 +8,19 @@ use axum::{
     },
     response::{IntoResponse, Response},
 };
-use image::ImageFormat;
-use koharu_app::{
-    AppResources, operations,
-    state_tx::{self, ChangedField},
-};
+use koharu_app::{AppResources, config as app_config, edit, io, llm, ml, pipeline};
 use koharu_core::{
-    ApiKeyResponse, ApiKeyValue, BootstrapConfig, CreateTextBlock, Document, DocumentDetail,
-    DocumentSummary, DownloadState, ExportLayer, ExportResult, FontFaceInfo, InpaintRegion,
-    JobState, JobStatus, LlmLoadRequest, LlmModelInfo, LlmPingRequest, LlmPingResponse,
-    MaskRegionRequest, MetaInfo, PipelineJobRequest, Region, RenderRequest, TextBlock,
-    TextBlockDetail, TextBlockInput, TextBlockPatch, TranslateRequest,
+    AppConfig, AppConfigUpdate, CreateTextBlock, Document, DocumentDetail, DocumentSummary,
+    DownloadState, ExportLayer, ExportResult, FontFaceInfo, JobState, JobStatus, LlmCatalog,
+    LlmLoadRequest, LlmState, MaskRegionRequest, MetaInfo, PipelineJobRequest, RenderRequest,
+    TextBlock, TextBlockDetail, TextBlockInput, TextBlockPatch, TranslateRequest,
 };
 use koharu_psd::{PsdExportOptions, TextLayerMode};
 use serde::{Deserialize, Serialize};
 use utoipa::IntoParams;
 use utoipa_axum::{router::OpenApiRouter, routes};
 
-use crate::{
-    shared::{SharedState, get_resources},
-    tracker::Tracker,
-};
+use crate::{shared::SharedState, tracker::Tracker};
 
 const MAX_BODY_SIZE: usize = 1024 * 1024 * 1024;
 
@@ -43,7 +32,9 @@ pub struct ApiState {
 
 impl ApiState {
     fn resources(&self) -> ApiResult<AppResources> {
-        get_resources(&self.resources).map_err(ApiError::service_unavailable)
+        self.resources.get().ok_or_else(|| {
+            ApiError::service_unavailable(anyhow::anyhow!("Resources not initialized"))
+        })
     }
 }
 
@@ -65,9 +56,7 @@ pub fn api() -> (axum::Router<ApiState>, utoipa::openapi::OpenApi) {
         .routes(routes!(export_document))
         .routes(routes!(batch_export))
         .routes(routes!(get_llm, load_llm, unload_llm))
-        .routes(routes!(list_llm_models))
-        .routes(routes!(check_llm_health))
-        .routes(routes!(get_api_key, set_api_key))
+        .routes(routes!(get_llm_catalog))
         .routes(routes!(start_pipeline))
         .routes(routes!(list_jobs))
         .routes(routes!(get_job, cancel_job))
@@ -75,7 +64,6 @@ pub fn api() -> (axum::Router<ApiState>, utoipa::openapi::OpenApi) {
         .routes(routes!(get_meta))
         .routes(routes!(list_fonts))
         .routes(routes!(get_config, update_config))
-        .routes(routes!(initialize))
         .split_for_parts()
 }
 
@@ -111,10 +99,6 @@ impl ApiError {
         Self::new(StatusCode::NOT_FOUND, message)
     }
 
-    fn conflict(message: impl Into<String>) -> Self {
-        Self::new(StatusCode::CONFLICT, message)
-    }
-
     fn service_unavailable(error: anyhow::Error) -> Self {
         Self::new(StatusCode::SERVICE_UNAVAILABLE, error.to_string())
     }
@@ -137,8 +121,7 @@ impl From<anyhow::Error> for ApiError {
 
 impl IntoResponse for ApiError {
     fn into_response(self) -> Response {
-        let status =
-            StatusCode::from_u16(self.status).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
+        let status = StatusCode::from_u16(self.status).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
         (status, Json(self)).into_response()
     }
 }
@@ -158,9 +141,8 @@ struct ImportQuery {
 
 #[derive(Debug, Deserialize, IntoParams)]
 #[serde(rename_all = "camelCase")]
-struct LlmModelsQuery {
+struct LlmCatalogQuery {
     language: Option<String>,
-    openai_compatible_base_url: Option<String>,
 }
 
 #[derive(Debug, Deserialize, IntoParams)]
@@ -185,12 +167,13 @@ struct ExportBatchRequest {
     operation_id = "getConfig",
     tag = "system",
     responses(
-        (status = 200, body = BootstrapConfig),
+        (status = 200, body = AppConfig),
         (status = 503, body = ApiError),
     ),
 )]
-async fn get_config(State(state): State<ApiState>) -> ApiResult<Json<BootstrapConfig>> {
-    let config = state.resources.get_config().map_err(ApiError::internal)?;
+async fn get_config() -> ApiResult<Json<AppConfig>> {
+    let stored = app_config::load().map_err(ApiError::internal)?;
+    let config = app_config::to_public_config(&stored).map_err(ApiError::internal)?;
     Ok(Json(config))
 }
 
@@ -199,45 +182,22 @@ async fn get_config(State(state): State<ApiState>) -> ApiResult<Json<BootstrapCo
     path = "/config",
     operation_id = "updateConfig",
     tag = "system",
-    request_body = BootstrapConfig,
+    request_body = AppConfigUpdate,
     responses(
-        (status = 200, body = BootstrapConfig),
+        (status = 200, body = AppConfig),
         (status = 400, body = ApiError),
     ),
 )]
-async fn update_config(
-    State(state): State<ApiState>,
-    Json(config): Json<BootstrapConfig>,
-) -> ApiResult<Json<BootstrapConfig>> {
-    let saved = state.resources.put_config(config).map_err(ApiError::from)?;
+async fn update_config(Json(config): Json<AppConfigUpdate>) -> ApiResult<Json<AppConfig>> {
+    let current = app_config::load().map_err(ApiError::internal)?;
+    let stored = app_config::from_public_update(config.clone()).map_err(ApiError::from)?;
+    app_config::move_app_data_if_needed(&current, &stored).map_err(ApiError::internal)?;
+    app_config::save(&stored).map_err(ApiError::internal)?;
+    app_config::apply_secret_updates(&config).map_err(ApiError::from)?;
+    let saved = app_config::to_public_config(&stored).map_err(ApiError::internal)?;
     Ok(Json(saved))
 }
 
-#[utoipa::path(
-    post,
-    path = "/initialize",
-    operation_id = "initialize",
-    tag = "system",
-    responses(
-        (status = 204),
-        (status = 409, body = ApiError),
-        (status = 500, body = ApiError),
-    ),
-)]
-async fn initialize(State(state): State<ApiState>) -> ApiResult<StatusCode> {
-    match state.resources.initialize().await {
-        Ok(()) => Ok(StatusCode::NO_CONTENT),
-        Err(error) => {
-            let message = error.to_string();
-            if message.contains("already in progress") {
-                Err(ApiError::conflict(message))
-            } else {
-                Err(ApiError::internal(error))
-            }
-        }
-    }
-}
-
 #[utoipa::path(
     get,
     path = "/meta",
@@ -250,7 +210,7 @@ async fn initialize(State(state): State<ApiState>) -> ApiResult<StatusCode> {
 )]
 async fn get_meta(State(state): State<ApiState>) -> ApiResult<Json<MetaInfo>> {
     let resources = state.resources()?;
-    let device = operations::device(resources.clone()).await?;
+    let device = io::device(resources.clone()).await?;
     Ok(Json(MetaInfo {
         version: resources.version.to_string(),
         ml_device: device.ml_device,
@@ -269,7 +229,7 @@ async fn get_meta(State(state): State<ApiState>) -> ApiResult<Json<MetaInfo>> {
 )]
 async fn list_fonts(State(state): State<ApiState>) -> ApiResult<Json<Vec<FontFaceInfo>>> {
     let resources = state.resources()?;
-    let fonts = operations::list_font_families(resources)
+    let fonts = ml::list_font_families(resources)
         .await
         .map_err(ApiError::from)?;
     Ok(Json(fonts))
@@ -291,8 +251,10 @@ async fn list_fonts(State(state): State<ApiState>) -> ApiResult<Json<Vec<FontFac
 )]
 async fn list_documents(State(state): State<ApiState>) -> ApiResult<Json<Vec<DocumentSummary>>> {
     let resources = state.resources()?;
-    let guard = resources.state.read().await;
-    let documents = guard.documents.iter().map(DocumentSummary::from).collect();
+    let documents = resources
+        .cache
+        .list_documents()
+        .map_err(ApiError::internal)?;
     Ok(Json(documents))
 }
 
@@ -313,20 +275,45 @@ async fn get_document(
     Path(document_id): Path<String>,
 ) -> ApiResult<Json<DocumentDetail>> {
     let resources = state.resources()?;
-    let guard = resources.state.read().await;
-    let doc = guard
-        .documents
-        .iter()
-        .find(|d| d.id == document_id)
-        .ok_or_else(|| ApiError::not_found("Document not found"))?;
+    let doc = resources
+        .cache
+        .get(&document_id)
+        .await
+        .map_err(|_| ApiError::not_found("Document not found"))?;
 
-    let image = serde_bytes::ByteBuf::from(encode_webp(&doc.image)?);
-    let segment = doc.segment.as_ref().map(|s| encode_webp(s).map(serde_bytes::ByteBuf::from)).transpose()?;
-    let inpainted = doc.inpainted.as_ref().map(|s| encode_webp(s).map(serde_bytes::ByteBuf::from)).transpose()?;
-    let brush_layer = doc.brush_layer.as_ref().map(|s| encode_webp(s).map(serde_bytes::ByteBuf::from)).transpose()?;
-    let rendered = doc.rendered.as_ref().map(|s| encode_webp(s).map(serde_bytes::ByteBuf::from)).transpose()?;
+    let image = serde_bytes::ByteBuf::from(
+        koharu_app::utils::encode_image(&doc.image, "webp").map_err(ApiError::internal)?,
+    );
+    let segment = doc
+        .segment
+        .as_ref()
+        .map(|s| koharu_app::utils::encode_image(s, "webp").map(serde_bytes::ByteBuf::from))
+        .transpose()
+        .map_err(ApiError::internal)?;
+    let inpainted = doc
+        .inpainted
+        .as_ref()
+        .map(|s| koharu_app::utils::encode_image(s, "webp").map(serde_bytes::ByteBuf::from))
+        .transpose()
+        .map_err(ApiError::internal)?;
+    let brush_layer = doc
+        .brush_layer
+        .as_ref()
+        .map(|s| koharu_app::utils::encode_image(s, "webp").map(serde_bytes::ByteBuf::from))
+        .transpose()
+        .map_err(ApiError::internal)?;
+    let rendered = doc
+        .rendered
+        .as_ref()
+        .map(|s| koharu_app::utils::encode_image(s, "webp").map(serde_bytes::ByteBuf::from))
+        .transpose()
+        .map_err(ApiError::internal)?;
 
-    let text_blocks = doc.text_blocks.iter().map(koharu_core::TextBlockDetail::from).collect();
+    let text_blocks = doc
+        .text_blocks
+        .iter()
+        .map(koharu_core::TextBlockDetail::from)
+        .collect();
 
     let detail = DocumentDetail {
         id: doc.id.clone(),
@@ -334,7 +321,6 @@ async fn get_document(
         name: doc.name.clone(),
         width: doc.width,
         height: doc.height,
-        revision: doc.revision,
         text_blocks,
         image,
         segment,
@@ -343,7 +329,6 @@ async fn get_document(
         rendered,
     };
 
-    drop(guard);
     Ok(Json(detail))
 }
 
@@ -372,16 +357,15 @@ async fn get_document_thumbnail(
 ) -> ApiResult<Response> {
     let size = query.size.unwrap_or(200).min(800);
     let resources = state.resources()?;
-    let guard = resources.state.read().await;
-    let doc = guard
-        .documents
-        .iter()
-        .find(|d| d.id == document_id)
-        .ok_or_else(|| ApiError::not_found("Document not found"))?;
+    let doc = resources
+        .cache
+        .get(&document_id)
+        .await
+        .map_err(|_| ApiError::not_found("Document not found"))?;
     let source = doc.rendered.as_ref().unwrap_or(&doc.image);
     let thumbnail = source.thumbnail(size, size);
-    let bytes = encode_webp(&thumbnail.into())?;
-    drop(guard);
+    let bytes =
+        koharu_app::utils::encode_image(&thumbnail.into(), "webp").map_err(ApiError::internal)?;
     Ok(binary_response(bytes, "image/webp", None))
 }
 
@@ -404,7 +388,7 @@ async fn import_documents(
     mut multipart: Multipart,
 ) -> ApiResult<Json<koharu_core::ImportResult>> {
     let resources = state.resources()?;
-    let mut files = Vec::new();
+    let mut uploaded_files = Vec::new();
 
     while let Some(field) = multipart
         .next_field()
@@ -419,31 +403,32 @@ async fn import_documents(
             .bytes()
             .await
             .map_err(|error| ApiError::bad_request(error.to_string()))?;
-        files.push(koharu_core::FileEntry {
-            name: filename,
-            data: data.to_vec(),
-        });
+        uploaded_files.push((filename, data.to_vec()));
     }
 
-    if files.is_empty() {
+    if uploaded_files.is_empty() {
         return Err(ApiError::bad_request("No files uploaded"));
     }
 
+    let files = uploaded_files
+        .into_iter()
+        .map(|(name, data)| koharu_core::FileEntry { name, data })
+        .collect();
+
     let payload = koharu_core::OpenDocumentsPayload { files };
     match query.mode.unwrap_or(koharu_core::ImportMode::Replace) {
         koharu_core::ImportMode::Replace => {
-            operations::open_documents(resources.clone(), payload).await?;
+            io::open_documents(resources.clone(), payload).await?;
         }
         koharu_core::ImportMode::Append => {
-            operations::add_documents(resources.clone(), payload).await?;
+            io::add_documents(resources.clone(), payload).await?;
         }
     }
 
-    let documents = state_tx::list_docs(&resources.state)
-        .await
-        .iter()
-        .map(DocumentSummary::from)
-        .collect::<Vec<_>>();
+    let documents = resources
+        .cache
+        .list_documents()
+        .map_err(ApiError::internal)?;
 
     Ok(Json(koharu_core::ImportResult {
         total_count: documents.len(),
@@ -472,8 +457,7 @@ async fn detect_document(
     Path(document_id): Path<String>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-    operations::detect(resources, koharu_core::IndexPayload { index }).await?;
+    ml::detect(resources, &document_id).await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
@@ -494,8 +478,7 @@ async fn recognize_document(
     Path(document_id): Path<String>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-    operations::ocr(resources, koharu_core::IndexPayload { index }).await?;
+    ml::ocr(resources, &document_id).await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
@@ -516,8 +499,7 @@ async fn inpaint_document(
     Path(document_id): Path<String>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-    operations::inpaint(resources, koharu_core::IndexPayload { index }).await?;
+    ml::inpaint(resources, &document_id).await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
@@ -540,22 +522,20 @@ async fn render_document(
     Json(request): Json<RenderRequest>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, document) = find_document(&resources, &document_id).await?;
+    let document = find_document(&resources, &document_id).await?;
     let text_block_index = request
         .text_block_id
         .as_deref()
         .map(|id| find_text_block_index(&document, id))
         .transpose()?;
 
-    operations::render(
+    ml::render(
         resources,
-        koharu_core::RenderPayload {
-            index,
-            text_block_index,
-            shader_effect: request.shader_effect,
-            shader_stroke: request.shader_stroke,
-            font_family: request.font_family,
-        },
+        &document_id,
+        text_block_index,
+        request.shader_effect,
+        request.shader_stroke,
+        request.font_family.as_deref(),
     )
     .await?;
 
@@ -581,20 +561,18 @@ async fn translate_document(
     Json(request): Json<TranslateRequest>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, document) = find_document(&resources, &document_id).await?;
+    let document = find_document(&resources, &document_id).await?;
     let text_block_index = request
         .text_block_id
         .as_deref()
         .map(|id| find_text_block_index(&document, id))
         .transpose()?;
 
-    operations::llm_generate(
+    llm::llm_generate(
         resources,
-        koharu_core::LlmGeneratePayload {
-            index,
-            text_block_index,
-            language: request.language,
-        },
+        &document_id,
+        text_block_index,
+        request.language.as_deref(),
     )
     .await?;
 
@@ -624,16 +602,7 @@ async fn update_mask(
     Json(request): Json<MaskRegionRequest>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-    operations::update_inpaint_mask(
-        resources,
-        koharu_core::UpdateInpaintMaskPayload {
-            index,
-            mask: request.data,
-            region: request.region.map(to_inpaint_region),
-        },
-    )
-    .await?;
+    edit::update_inpaint_mask(resources, &document_id, &request.data, request.region).await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
@@ -655,16 +624,7 @@ async fn update_brush_layer(
     Json(request): Json<koharu_core::BrushRegionRequest>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-    operations::update_brush_layer(
-        resources,
-        koharu_core::UpdateBrushLayerPayload {
-            index,
-            patch: request.data,
-            region: to_inpaint_region(request.region),
-        },
-    )
-    .await?;
+    edit::update_brush_layer(resources, &document_id, &request.data, request.region).await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
@@ -686,15 +646,7 @@ async fn inpaint_region(
     Json(request): Json<koharu_core::InpaintRegionRequest>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-    operations::inpaint_partial(
-        resources,
-        koharu_core::InpaintPartialPayload {
-            index,
-            region: to_inpaint_region(request.region),
-        },
-    )
-    .await?;
+    edit::inpaint_partial(resources, &document_id, request.region).await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
@@ -721,31 +673,32 @@ async fn create_text_block(
     Json(request): Json<CreateTextBlock>,
 ) -> ApiResult<Json<TextBlockDetail>> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-
-    let detail = state_tx::mutate_doc(
-        &resources.state,
-        index,
-        &[ChangedField::TextBlocks],
-        |document| {
-            let mut block = TextBlock {
-                x: request.x,
-                y: request.y,
-                width: request.width,
-                height: request.height,
-                confidence: 1.0,
-                ..Default::default()
-            };
-            block.set_layout_seed(block.x, block.y, block.width, block.height);
-            document.text_blocks.push(block);
-            let block = document
-                .text_blocks
-                .last()
-                .ok_or_else(|| anyhow::anyhow!("Failed to append text block"))?;
-            Ok(TextBlockDetail::from(block))
-        },
-    )
-    .await?;
+    let mut doc = resources
+        .cache
+        .get(&document_id)
+        .await
+        .map_err(|_| ApiError::not_found("Document not found"))?;
+
+    let mut block = TextBlock {
+        x: request.x,
+        y: request.y,
+        width: request.width,
+        height: request.height,
+        confidence: 1.0,
+        ..Default::default()
+    };
+    block.set_layout_seed(block.x, block.y, block.width, block.height);
+    doc.text_blocks.push(block);
+    let detail = doc
+        .text_blocks
+        .last()
+        .map(TextBlockDetail::from)
+        .ok_or_else(|| ApiError::internal(anyhow::anyhow!("Failed to append text block")))?;
+    resources
+        .cache
+        .put(&doc)
+        .await
+        .map_err(ApiError::internal)?;
 
     Ok(Json(detail))
 }
@@ -769,91 +722,77 @@ async fn put_text_blocks(
     Json(inputs): Json<Vec<TextBlockInput>>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-
-    let any_content_changed = state_tx::mutate_doc(
-        &resources.state,
-        index,
-        &[ChangedField::TextBlocks],
-        |document| {
-            let mut any_changed = false;
-
-            // Build a set of incoming IDs for deletion detection
-            let incoming_ids: std::collections::HashSet<&str> = inputs
-                .iter()
-                .filter_map(|input| input.id.as_deref())
-                .collect();
-
-            // Delete blocks not present in the incoming array
-            let before_len = document.text_blocks.len();
-            document
-                .text_blocks
-                .retain(|block| incoming_ids.contains(block.id.as_str()));
-            if document.text_blocks.len() != before_len {
-                any_changed = true;
-            }
 
-            for input in &inputs {
-                if let Some(ref id) = input.id {
-                    // Update existing block
-                    if let Some(block) = document
-                        .text_blocks
-                        .iter_mut()
-                        .find(|b| &b.id == id)
-                    {
-                        let patch = TextBlockPatch {
-                            text: input.text.clone(),
-                            translation: input.translation.clone(),
-                            x: Some(input.x),
-                            y: Some(input.y),
-                            width: Some(input.width),
-                            height: Some(input.height),
-                            style: input.style.clone(),
-                        };
-                        let had_render = block.rendered.is_some();
-                        apply_text_block_patch(block, patch);
-                        // Content changed if the render was invalidated
-                        if had_render && block.rendered.is_none() {
-                            any_changed = true;
-                        }
-                    }
-                } else {
-                    // Create new block
-                    let mut block = TextBlock {
-                        x: input.x,
-                        y: input.y,
-                        width: input.width,
-                        height: input.height,
-                        text: input.text.clone(),
-                        translation: input.translation.clone(),
-                        style: input.style.clone(),
-                        confidence: 1.0,
-                        ..Default::default()
-                    };
-                    block.set_layout_seed(block.x, block.y, block.width, block.height);
-                    document.text_blocks.push(block);
+    let mut doc = resources
+        .cache
+        .get(&document_id)
+        .await
+        .map_err(|_| ApiError::not_found("Document not found"))?;
+
+    let mut any_changed = false;
+
+    // Build a set of incoming IDs for deletion detection
+    let incoming_ids: std::collections::HashSet<&str> = inputs
+        .iter()
+        .filter_map(|input| input.id.as_deref())
+        .collect();
+
+    // Delete blocks not present in the incoming array
+    let before_len = doc.text_blocks.len();
+    doc.text_blocks
+        .retain(|block| incoming_ids.contains(block.id.as_str()));
+    if doc.text_blocks.len() != before_len {
+        any_changed = true;
+    }
+
+    for input in &inputs {
+        if let Some(ref id) = input.id {
+            // Update existing block
+            if let Some(block) = doc.text_blocks.iter_mut().find(|b| &b.id == id) {
+                let patch = TextBlockPatch {
+                    text: input.text.clone(),
+                    translation: input.translation.clone(),
+                    x: Some(input.x),
+                    y: Some(input.y),
+                    width: Some(input.width),
+                    height: Some(input.height),
+                    style: input.style.clone(),
+                };
+                let had_render = block.rendered.is_some();
+                apply_text_block_patch(block, patch);
+                // Content changed if the render was invalidated
+                if had_render && block.rendered.is_none() {
                     any_changed = true;
                 }
             }
+        } else {
+            // Create new block
+            let mut block = TextBlock {
+                x: input.x,
+                y: input.y,
+                width: input.width,
+                height: input.height,
+                text: input.text.clone(),
+                translation: input.translation.clone(),
+                style: input.style.clone(),
+                confidence: 1.0,
+                ..Default::default()
+            };
+            block.set_layout_seed(block.x, block.y, block.width, block.height);
+            doc.text_blocks.push(block);
+            any_changed = true;
+        }
+    }
 
-            Ok(any_changed)
-        },
-    )
-    .await?;
+    resources
+        .cache
+        .put(&doc)
+        .await
+        .map_err(ApiError::internal)?;
 
     // Auto-render if any block content/geometry changed
-    if any_content_changed {
-        let _ = operations::render(
-            resources,
-            koharu_core::RenderPayload {
-                index,
-                text_block_index: None,
-                shader_effect: None,
-                shader_stroke: None,
-                font_family: None,
-            },
-        )
-        .await;
+    if any_changed {
+        let _ = ml::render(resources, &document_id, None, None, None, None).await;
     }
 
     Ok(StatusCode::NO_CONTENT)
@@ -881,23 +820,23 @@ async fn patch_text_block(
     Json(request): Json<TextBlockPatch>,
 ) -> ApiResult<Json<TextBlockDetail>> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-
-    let detail = state_tx::mutate_doc(
-        &resources.state,
-        index,
-        &[ChangedField::TextBlocks],
-        |document| {
-            let block = document
-                .text_blocks
-                .iter_mut()
-                .find(|block| block.id == text_block_id)
-                .ok_or_else(|| anyhow::anyhow!("Text block not found: {text_block_id}"))?;
-            apply_text_block_patch(block, request.clone());
-            Ok(TextBlockDetail::from(&*block))
-        },
-    )
-    .await?;
+    let mut doc = resources
+        .cache
+        .get(&document_id)
+        .await
+        .map_err(|_| ApiError::not_found("Document not found"))?;
+    let block = doc
+        .text_blocks
+        .iter_mut()
+        .find(|block| block.id == text_block_id)
+        .ok_or_else(|| ApiError::not_found(format!("Text block not found: {text_block_id}")))?;
+    apply_text_block_patch(block, request);
+    let detail = TextBlockDetail::from(&*block);
+    resources
+        .cache
+        .put(&doc)
+        .await
+        .map_err(ApiError::internal)?;
 
     Ok(Json(detail))
 }
@@ -922,23 +861,22 @@ async fn delete_text_block(
     Path((document_id, text_block_id)): Path<(String, String)>,
 ) -> ApiResult<StatusCode> {
     let resources = state.resources()?;
-    let (index, _) = find_document(&resources, &document_id).await?;
-
-    state_tx::mutate_doc(
-        &resources.state,
-        index,
-        &[ChangedField::TextBlocks],
-        |document| {
-            let block_index = document
-                .text_blocks
-                .iter()
-                .position(|block| block.id == text_block_id)
-                .ok_or_else(|| anyhow::anyhow!("Text block not found: {text_block_id}"))?;
-            document.text_blocks.remove(block_index);
-            Ok(())
-        },
-    )
-    .await?;
+    let mut doc = resources
+        .cache
+        .get(&document_id)
+        .await
+        .map_err(|_| ApiError::not_found("Document not found"))?;
+    let block_index = doc
+        .text_blocks
+        .iter()
+        .position(|block| block.id == text_block_id)
+        .ok_or_else(|| ApiError::not_found(format!("Text block not found: {text_block_id}")))?;
+    doc.text_blocks.remove(block_index);
+    resources
+        .cache
+        .put(&doc)
+        .await
+        .map_err(ApiError::internal)?;
 
     Ok(StatusCode::NO_CONTENT)
 }
@@ -949,36 +887,23 @@ async fn delete_text_block(
 
 #[utoipa::path(
     get,
-    path = "/llm/models",
-    operation_id = "listLlmModels",
+    path = "/llm/catalog",
+    operation_id = "getLlmCatalog",
     tag = "llm",
-    params(LlmModelsQuery),
+    params(LlmCatalogQuery),
     responses(
-        (status = 200, body = Vec<LlmModelInfo>),
+        (status = 200, body = LlmCatalog),
         (status = 503, body = ApiError),
     ),
 )]
-async fn list_llm_models(
+async fn get_llm_catalog(
     State(state): State<ApiState>,
-    Query(query): Query<LlmModelsQuery>,
-) -> ApiResult<Json<Vec<LlmModelInfo>>> {
+    Query(query): Query<LlmCatalogQuery>,
+) -> ApiResult<Json<LlmCatalog>> {
     let resources = state.resources()?;
-    let models = operations::llm_list(
-        resources,
-        koharu_core::LlmListPayload {
-            language: query.language,
-            openai_compatible_base_url: query.openai_compatible_base_url,
-        },
-    )
-    .await?
-    .into_iter()
-    .map(|model| LlmModelInfo {
-        id: model.id,
-        languages: model.languages,
-        source: model.source.to_string(),
-    })
-    .collect();
-    Ok(Json(models))
+    Ok(Json(
+        llm::llm_catalog(resources, query.language.as_deref()).await?,
+    ))
 }
 
 #[utoipa::path(
@@ -987,11 +912,11 @@ async fn list_llm_models(
     operation_id = "getLlm",
     tag = "llm",
     responses(
-        (status = 200, body = koharu_core::LlmState),
+        (status = 200, body = LlmState),
         (status = 503, body = ApiError),
     ),
 )]
-async fn get_llm(State(state): State<ApiState>) -> ApiResult<Json<koharu_core::LlmState>> {
+async fn get_llm(State(state): State<ApiState>) -> ApiResult<Json<LlmState>> {
     let resources = state.resources()?;
     Ok(Json(resources.llm.snapshot().await))
 }
@@ -1003,7 +928,7 @@ async fn get_llm(State(state): State<ApiState>) -> ApiResult<Json<koharu_core::L
     tag = "llm",
     request_body = LlmLoadRequest,
     responses(
-        (status = 200, body = koharu_core::LlmState),
+        (status = 200, body = LlmState),
         (status = 400, body = ApiError),
         (status = 503, body = ApiError),
     ),
@@ -1011,20 +936,9 @@ async fn get_llm(State(state): State<ApiState>) -> ApiResult<Json<koharu_core::L
 async fn load_llm(
     State(state): State<ApiState>,
     Json(request): Json<LlmLoadRequest>,
-) -> ApiResult<Json<koharu_core::LlmState>> {
+) -> ApiResult<Json<LlmState>> {
     let resources = state.resources()?;
-    operations::llm_load(
-        resources.clone(),
-        koharu_core::LlmLoadPayload {
-            id: request.id,
-            api_key: request.api_key,
-            base_url: request.base_url,
-            temperature: request.temperature,
-            max_tokens: request.max_tokens,
-            custom_system_prompt: request.custom_system_prompt,
-        },
-    )
-    .await?;
+    llm::llm_load(resources.clone(), request).await?;
     Ok(Json(resources.llm.snapshot().await))
 }
 
@@ -1034,108 +948,16 @@ async fn load_llm(
     operation_id = "unloadLlm",
     tag = "llm",
     responses(
-        (status = 200, body = koharu_core::LlmState),
+        (status = 200, body = LlmState),
         (status = 503, body = ApiError),
     ),
 )]
-async fn unload_llm(State(state): State<ApiState>) -> ApiResult<Json<koharu_core::LlmState>> {
+async fn unload_llm(State(state): State<ApiState>) -> ApiResult<Json<LlmState>> {
     let resources = state.resources()?;
-    operations::llm_offload(resources.clone()).await?;
+    llm::llm_offload(resources.clone()).await?;
     Ok(Json(resources.llm.snapshot().await))
 }
 
-#[utoipa::path(
-    post,
-    path = "/llm/health",
-    operation_id = "checkLlmHealth",
-    tag = "llm",
-    request_body = LlmPingRequest,
-    responses(
-        (status = 200, body = LlmPingResponse),
-    ),
-)]
-async fn check_llm_health(
-    State(state): State<ApiState>,
-    Json(request): Json<LlmPingRequest>,
-) -> ApiResult<Json<LlmPingResponse>> {
-    match operations::llm_ping(
-        state.resources.runtime().http_client(),
-        &request.base_url,
-        request.api_key.as_deref(),
-    )
-    .await
-    {
-        Ok(result) => Ok(Json(LlmPingResponse {
-            ok: true,
-            models: result.models,
-            latency_ms: Some(result.latency_ms),
-            error: None,
-        })),
-        Err(err) => Ok(Json(LlmPingResponse {
-            ok: false,
-            models: vec![],
-            latency_ms: None,
-            error: Some(err.to_string()),
-        })),
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Providers
-// ---------------------------------------------------------------------------
-
-#[utoipa::path(
-    get,
-    path = "/providers/{provider}/api-key",
-    operation_id = "getApiKey",
-    tag = "providers",
-    params(("provider" = String, Path,)),
-    responses(
-        (status = 200, body = ApiKeyResponse),
-        (status = 503, body = ApiError),
-    ),
-)]
-async fn get_api_key(
-    State(state): State<ApiState>,
-    Path(provider): Path<String>,
-) -> ApiResult<Json<ApiKeyResponse>> {
-    let resources = state.resources()?;
-    let result =
-        operations::get_api_key(resources, koharu_core::ApiKeyGetPayload { provider }).await?;
-    Ok(Json(ApiKeyResponse {
-        api_key: result.api_key,
-    }))
-}
-
-#[utoipa::path(
-    put,
-    path = "/providers/{provider}/api-key",
-    operation_id = "setApiKey",
-    tag = "providers",
-    params(("provider" = String, Path,)),
-    request_body = ApiKeyValue,
-    responses(
-        (status = 204),
-        (status = 503, body = ApiError),
-    ),
-)]
-async fn set_api_key(
-    State(state): State<ApiState>,
-    Path(provider): Path<String>,
-    Json(request): Json<ApiKeyValue>,
-) -> ApiResult<StatusCode> {
-    let resources = state.resources()?;
-    operations::set_api_key(
-        resources,
-        koharu_core::ApiKeySetPayload {
-            provider,
-            api_key: request.api_key,
-        },
-    )
-    .await?;
-    Ok(StatusCode::NO_CONTENT)
-}
-
 // ---------------------------------------------------------------------------
 // Jobs
 // ---------------------------------------------------------------------------
@@ -1156,31 +978,38 @@ async fn start_pipeline(
     Json(request): Json<PipelineJobRequest>,
 ) -> ApiResult<Json<JobState>> {
     let resources = state.resources()?;
-    let index = if let Some(document_id) = request.document_id.as_deref() {
-        Some(state_tx::find_doc_index(&resources.state, document_id).await?)
-    } else {
-        None
-    };
-    let total_documents = match index {
+    // Validate document_id exists if provided
+    if let Some(document_id) = request.document_id.as_deref() {
+        let entries = resources
+            .cache
+            .list_documents()
+            .map_err(ApiError::internal)?;
+        if !entries.iter().any(|d| d.id == document_id) {
+            return Err(ApiError::not_found(format!(
+                "Document not found: {document_id}"
+            )));
+        }
+    }
+    let total_documents = match &request.document_id {
         Some(_) => 1,
-        None => state_tx::doc_count(&resources.state).await,
+        None => resources
+            .cache
+            .list_documents()
+            .map_err(ApiError::internal)?
+            .len(),
     };
 
-    let job_id = operations::process(
+    let job_id = pipeline::process(
         resources.clone(),
         koharu_core::ProcessRequest {
-            index,
-            llm_model_id: request.llm_model_id,
-            llm_api_key: request.llm_api_key,
-            llm_base_url: request.llm_base_url,
-            llm_temperature: request.llm_temperature,
-            llm_max_tokens: request.llm_max_tokens,
-            llm_custom_system_prompt: request.llm_custom_system_prompt,
+            document_id: request.document_id.clone(),
+            llm: request.llm.clone(),
             language: request.language,
             shader_effect: request.shader_effect,
             shader_stroke: request.shader_stroke,
             font_family: request.font_family,
         },
+        state.tracker.jobs(),
     )
     .await?;
 
@@ -1312,15 +1141,21 @@ async fn export_document(
     Query(query): Query<ExportQuery>,
 ) -> ApiResult<Response> {
     let resources = state.resources()?;
-    let (_, document) = find_document(&resources, &document_id).await?;
+    let document = find_document(&resources, &document_id).await?;
 
     if format == "psd" {
-        let data = koharu_psd::export_document(&document, &app_psd_export_options())
-            .map_err(|error| ApiError::bad_request(error.to_string()))?;
+        let data = koharu_psd::export_document(
+            &document,
+            &PsdExportOptions {
+                text_layer_mode: TextLayerMode::Editable,
+                ..PsdExportOptions::default()
+            },
+        )
+        .map_err(|error| ApiError::bad_request(error.to_string()))?;
         return Ok(binary_response(
             data,
             "image/vnd.adobe.photoshop",
-            Some(psd_export_filename(&document)),
+            Some(format!("{}_koharu.psd", document.name)),
         ));
     }
 
@@ -1332,8 +1167,8 @@ async fn export_document(
         .and_then(|value| value.to_str())
         .unwrap_or("jpg")
         .to_ascii_lowercase();
-    let data = encode_image(image, &ext)?;
-    let content_type = mime_from_ext(&ext);
+    let data = koharu_app::utils::encode_image(image, &ext).map_err(ApiError::internal)?;
+    let content_type = koharu_app::utils::mime_from_ext(&ext);
     Ok(binary_response(data, content_type, Some(filename)))
 }
 
@@ -1354,23 +1189,18 @@ async fn batch_export(
 ) -> ApiResult<Json<ExportResult>> {
     let resources = state.resources()?;
     let count = match request.layer.unwrap_or(ExportLayer::Rendered) {
-        ExportLayer::Rendered => operations::export_all_rendered(resources).await?,
-        ExportLayer::Inpainted => operations::export_all_inpainted(resources).await?,
+        ExportLayer::Rendered => io::export_all_rendered(resources).await?,
+        ExportLayer::Inpainted => io::export_all_inpainted(resources).await?,
     };
     Ok(Json(ExportResult { count }))
 }
 
-async fn find_document(
-    resources: &AppResources,
-    document_id: &str,
-) -> ApiResult<(usize, Document)> {
-    let index = state_tx::find_doc_index(&resources.state, document_id)
-        .await
-        .map_err(ApiError::from)?;
-    let document = state_tx::read_doc(&resources.state, index)
+async fn find_document(resources: &AppResources, document_id: &str) -> ApiResult<Document> {
+    resources
+        .cache
+        .get(document_id)
         .await
-        .map_err(ApiError::from)?;
-    Ok((index, document))
+        .map_err(|_| ApiError::not_found(format!("Document not found: {document_id}")))
 }
 
 fn find_text_block_index(document: &Document, text_block_id: &str) -> ApiResult<usize> {
@@ -1381,21 +1211,6 @@ fn find_text_block_index(document: &Document, text_block_id: &str) -> ApiResult<
         .ok_or_else(|| ApiError::not_found(format!("Text block not found: {text_block_id}")))
 }
 
-fn encode_webp(image: &koharu_core::SerializableDynamicImage) -> ApiResult<Vec<u8>> {
-    encode_image(image, "webp")
-}
-
-fn encode_image(image: &koharu_core::SerializableDynamicImage, ext: &str) -> ApiResult<Vec<u8>> {
-    let format = ImageFormat::from_extension(ext).unwrap_or(ImageFormat::Jpeg);
-    let mut cursor = Cursor::new(Vec::new());
-    image
-        .0
-        .write_to(&mut cursor, format)
-        .with_context(|| format!("failed to encode image as {ext}"))
-        .map_err(ApiError::internal)?;
-    Ok(cursor.into_inner())
-}
-
 fn binary_response(data: Vec<u8>, content_type: &str, filename: Option<String>) -> Response {
     let mut response = Response::new(Body::from(data));
     response
@@ -1409,15 +1224,6 @@ fn binary_response(data: Vec<u8>, content_type: &str, filename: Option<String>)
     response
 }
 
-fn mime_from_ext(ext: &str) -> &'static str {
-    match ext {
-        "png" => "image/png",
-        "jpg" | "jpeg" => "image/jpeg",
-        "webp" => "image/webp",
-        _ => "application/octet-stream",
-    }
-}
-
 fn export_target(
     document: &Document,
     layer: ExportLayer,
@@ -1447,26 +1253,6 @@ fn export_target(
     }
 }
 
-fn psd_export_filename(document: &Document) -> String {
-    format!("{}_koharu.psd", document.name)
-}
-
-fn app_psd_export_options() -> PsdExportOptions {
-    PsdExportOptions {
-        text_layer_mode: TextLayerMode::Editable,
-        ..PsdExportOptions::default()
-    }
-}
-
-fn to_inpaint_region(region: Region) -> InpaintRegion {
-    InpaintRegion {
-        x: region.x,
-        y: region.y,
-        width: region.width,
-        height: region.height,
-    }
-}
-
 fn apply_text_block_patch(block: &mut TextBlock, patch: TextBlockPatch) {
     let previous_width = block.width;
     let previous_height = block.height;
@@ -1530,9 +1316,8 @@ fn apply_text_block_patch(block: &mut TextBlock, patch: TextBlockPatch) {
 
 #[cfg(test)]
 mod tests {
-    use super::{app_psd_export_options, apply_text_block_patch, psd_export_filename};
-    use koharu_core::{Document, TextAlign, TextBlock, TextBlockPatch, TextDirection, TextStyle};
-    use koharu_psd::TextLayerMode;
+    use super::apply_text_block_patch;
+    use koharu_core::{TextAlign, TextBlock, TextBlockPatch, TextDirection, TextStyle};
 
     #[test]
     fn text_block_patch_updates_geometry_and_clears_rendered() {
@@ -1573,22 +1358,4 @@ mod tests {
         assert!(block.rendered.is_none());
         assert!(block.rendered_direction.is_none());
     }
-
-    #[test]
-    fn psd_export_filename_uses_koharu_suffix() {
-        let document = Document {
-            name: "chapter-01".to_string(),
-            ..Default::default()
-        };
-
-        assert_eq!(psd_export_filename(&document), "chapter-01_koharu.psd");
-    }
-
-    #[test]
-    fn app_psd_export_uses_editable_text_layers() {
-        assert_eq!(
-            app_psd_export_options().text_layer_mode,
-            TextLayerMode::Editable
-        );
-    }
 }

koharu-rpc/src/lib.rs

@@ -4,4 +4,4 @@ pub mod server;
 pub mod shared;
 pub mod tracker;
 
-pub use shared::{BootstrapHooks, SharedState};
+pub use shared::SharedState;

koharu-rpc/src/mcp/mod.rs

@@ -1,6 +1,8 @@
 mod helpers;
 
+use std::collections::HashMap;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 use image::DynamicImage;
 use rmcp::handler::server::router::tool::ToolRouter;
@@ -10,17 +12,17 @@ use rmcp::model::{
     ToolsCapability,
 };
 use rmcp::{ServerHandler, tool, tool_handler, tool_router};
+use tokio::sync::RwLock;
 
-use koharu_app::AppResources;
-use koharu_app::operations;
+use koharu_app::{AppResources, edit, io, llm, ml, pipeline};
 use koharu_core::commands::{
-    AddTextBlockPayload, ExportDocumentParams, FileEntry, IndexPayload, InpaintPartialPayload,
-    InpaintRegion, InpaintRegionParams, LlmGenerateParams, LlmGeneratePayload, LlmListPayload,
-    LlmLoadParams, LlmLoadPayload, MaskMorphPayload, OpenDocumentsParams, OpenDocumentsPayload,
-    ProcessParams, ProcessRequest, RemoveTextBlockPayload, RenderParams, RenderPayload,
-    UpdateTextBlockPayload, ViewImageParams, ViewTextBlockParams,
+    AddTextBlockPayload, DocumentIdParam, ExportDocumentParams, FileEntry, InpaintRegionParams,
+    LlmGenerateParams, LlmLoadParams, MaskMorphPayload, OpenDocumentsParams, OpenDocumentsPayload,
+    ProcessParams, ProcessRequest, RemoveTextBlockPayload, RenderParams, UpdateTextBlockPayload,
+    ViewImageParams, ViewTextBlockParams,
 };
 use koharu_core::views::to_doc_info;
+use koharu_core::{LlmLoadRequest, PipelineLlmRequest, Region};
 
 use crate::shared::SharedState;
 
@@ -45,6 +47,21 @@ impl KoharuMcp {
             .get()
             .ok_or_else(|| "Resources not initialized yet".to_string())
     }
+
+    async fn document_id_for_index(
+        &self,
+        resources: &AppResources,
+        index: usize,
+    ) -> Result<String, String> {
+        let entries = resources
+            .cache
+            .list_documents()
+            .map_err(|e| e.to_string())?;
+        entries
+            .get(index)
+            .map(|page| page.id.clone())
+            .ok_or_else(|| format!("Document index {index} not found"))
+    }
 }
 
 #[tool_router]
@@ -52,24 +69,20 @@ impl KoharuMcp {
     #[tool(description = "Get the application version")]
     async fn app_version(&self) -> Result<String, String> {
         let res = self.resources()?;
-        operations::app_version(res)
-            .await
-            .map_err(|e| e.to_string())
+        io::app_version(res).await.map_err(|e| e.to_string())
     }
 
     #[tool(description = "Get device information (ML device, GPU info)")]
     async fn device(&self) -> Result<String, String> {
         let res = self.resources()?;
-        let info = operations::device(res).await.map_err(|e| e.to_string())?;
+        let info = io::device(res).await.map_err(|e| e.to_string())?;
         serde_json::to_string_pretty(&info).map_err(|e| e.to_string())
     }
 
     #[tool(description = "Get the number of loaded documents")]
     async fn get_documents(&self) -> Result<String, String> {
         let res = self.resources()?;
-        let count = operations::get_documents(res)
-            .await
-            .map_err(|e| e.to_string())?;
+        let count = io::get_documents(res).await.map_err(|e| e.to_string())?;
         Ok(format!("{count} document(s) loaded"))
     }
 
@@ -78,10 +91,10 @@ impl KoharuMcp {
     )]
     async fn get_document(
         &self,
-        Parameters(p): Parameters<IndexPayload>,
+        Parameters(p): Parameters<DocumentIdParam>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        let doc = operations::get_document(res, p)
+        let doc = io::get_document(res, &p.document_id)
             .await
             .map_err(|e| e.to_string())?;
         let info = to_doc_info(&doc);
@@ -91,7 +104,7 @@ impl KoharuMcp {
     #[tool(description = "List available font families for text rendering")]
     async fn list_font_families(&self) -> Result<String, String> {
         let res = self.resources()?;
-        let fonts = operations::list_font_families(res)
+        let fonts = ml::list_font_families(res)
             .await
             .map_err(|e| e.to_string())?;
         Ok(fonts
@@ -101,27 +114,21 @@ impl KoharuMcp {
             .join(", "))
     }
 
-    #[tool(description = "List available LLM translation models with supported languages")]
+    #[tool(
+        description = "List the grouped LLM catalog for local models and configured remote providers"
+    )]
     async fn llm_list(&self) -> Result<String, String> {
         let res = self.resources()?;
-        let models = operations::llm_list(
-            res,
-            LlmListPayload {
-                language: None,
-                openai_compatible_base_url: None,
-            },
-        )
-        .await
-        .map_err(|e| e.to_string())?;
-        serde_json::to_string_pretty(&models).map_err(|e| e.to_string())
+        let catalog = llm::llm_catalog(res, None)
+            .await
+            .map_err(|e| e.to_string())?;
+        serde_json::to_string_pretty(&catalog).map_err(|e| e.to_string())
     }
 
     #[tool(description = "Check if an LLM model is loaded and ready")]
     async fn llm_ready(&self) -> Result<String, String> {
         let res = self.resources()?;
-        let ready = operations::llm_ready(res)
-            .await
-            .map_err(|e| e.to_string())?;
+        let ready = llm::llm_ready(res).await.map_err(|e| e.to_string())?;
         Ok(if ready {
             "LLM is ready".to_string()
         } else {
@@ -139,7 +146,7 @@ impl KoharuMcp {
         let res = self
             .resources()
             .map_err(|e| ErrorData::internal_error(e, None))?;
-        let doc = operations::get_document(res, IndexPayload { index: p.index })
+        let doc = io::get_document(res, &p.document_id)
             .await
             .map_err(|e| ErrorData::internal_error(e.to_string(), None))?;
 
@@ -186,7 +193,7 @@ impl KoharuMcp {
         let res = self
             .resources()
             .map_err(|e| ErrorData::internal_error(e, None))?;
-        let doc = operations::get_document(res, IndexPayload { index: p.index })
+        let doc = io::get_document(res, &p.document_id)
             .await
             .map_err(|e| ErrorData::internal_error(e.to_string(), None))?;
 
@@ -264,12 +271,12 @@ impl KoharuMcp {
             })
             .collect();
 
-        let count = operations::open_documents(res.clone(), OpenDocumentsPayload { files: files? })
+        let count = io::open_documents(res.clone(), OpenDocumentsPayload { files: files? })
             .await
             .map_err(|e| e.to_string())?;
 
-        let guard = res.state.read().await;
-        let names: Vec<&str> = guard.documents.iter().map(|d| d.name.as_str()).collect();
+        let entries = res.cache.list_documents().map_err(|e| e.to_string())?;
+        let names: Vec<&str> = entries.iter().map(|d| d.name.as_str()).collect();
         Ok(format!("Loaded {count} document(s): {}", names.join(", ")))
     }
 
@@ -279,7 +286,7 @@ impl KoharuMcp {
         Parameters(p): Parameters<ExportDocumentParams>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        let result = operations::export_document(res, IndexPayload { index: p.index })
+        let result = io::export_document(res, &p.document_id)
             .await
             .map_err(|e| e.to_string())?;
 
@@ -292,13 +299,13 @@ impl KoharuMcp {
     #[tool(
         description = "Detect text blocks and fonts in a manga page. Finds speech bubbles, text regions, and predicts font properties."
     )]
-    async fn detect(&self, Parameters(p): Parameters<IndexPayload>) -> Result<String, String> {
+    async fn detect(&self, Parameters(p): Parameters<DocumentIdParam>) -> Result<String, String> {
         let res = self.resources()?;
-        operations::detect(res.clone(), p)
+        ml::detect(res.clone(), &p.document_id)
             .await
             .map_err(|e| e.to_string())?;
 
-        let doc = operations::get_document(res, p)
+        let doc = io::get_document(res, &p.document_id)
             .await
             .map_err(|e| e.to_string())?;
 
@@ -315,13 +322,13 @@ impl KoharuMcp {
     #[tool(
         description = "Run OCR (optical character recognition) on detected text blocks to extract the original text."
     )]
-    async fn ocr(&self, Parameters(p): Parameters<IndexPayload>) -> Result<String, String> {
+    async fn ocr(&self, Parameters(p): Parameters<DocumentIdParam>) -> Result<String, String> {
         let res = self.resources()?;
-        operations::ocr(res.clone(), p)
+        ml::ocr(res.clone(), &p.document_id)
             .await
             .map_err(|e| e.to_string())?;
 
-        let doc = operations::get_document(res, p)
+        let doc = io::get_document(res, &p.document_id)
             .await
             .map_err(|e| e.to_string())?;
 
@@ -336,9 +343,9 @@ impl KoharuMcp {
     #[tool(
         description = "Inpaint (remove) text from the image using the detection mask. Fills text regions with surrounding background."
     )]
-    async fn inpaint(&self, Parameters(p): Parameters<IndexPayload>) -> Result<String, String> {
+    async fn inpaint(&self, Parameters(p): Parameters<DocumentIdParam>) -> Result<String, String> {
         let res = self.resources()?;
-        operations::inpaint(res, p)
+        ml::inpaint(res, &p.document_id)
             .await
             .map_err(|e| e.to_string())?;
         Ok("Inpainting complete".to_string())
@@ -356,15 +363,13 @@ impl KoharuMcp {
             .transpose()
             .map_err(|e: anyhow::Error| e.to_string())?;
 
-        operations::render(
+        ml::render(
             res,
-            RenderPayload {
-                index: p.index,
-                text_block_index: p.text_block_index,
-                shader_effect: effect,
-                shader_stroke: None,
-                font_family: p.font_family,
-            },
+            &p.document_id,
+            p.text_block_index,
+            effect,
+            None,
+            p.font_family.as_deref(),
         )
         .await
         .map_err(|e| e.to_string())?;
@@ -377,28 +382,34 @@ impl KoharuMcp {
     )]
     async fn llm_load(&self, Parameters(p): Parameters<LlmLoadParams>) -> Result<String, String> {
         let res = self.resources()?;
-        operations::llm_load(
+        llm::llm_load(
             res,
-            LlmLoadPayload {
-                id: p.id.clone(),
-                api_key: None,
-                base_url: None,
-                temperature: p.temperature,
-                max_tokens: p.max_tokens,
-                custom_system_prompt: p.custom_system_prompt,
+            LlmLoadRequest {
+                target: p.target.clone(),
+                options: p.options.clone(),
             },
         )
         .await
         .map_err(|e| e.to_string())?;
-        Ok(format!("Loading model '{}'...", p.id))
+        Ok(format!(
+            "Loading {} target '{}'{}",
+            match p.target.kind {
+                koharu_core::LlmTargetKind::Local => "local",
+                koharu_core::LlmTargetKind::Provider => "provider",
+            },
+            p.target.model_id,
+            p.target
+                .provider_id
+                .as_deref()
+                .map(|provider| format!(" from {provider}"))
+                .unwrap_or_default()
+        ))
     }
 
     #[tool(description = "Unload the current LLM model from memory")]
     async fn llm_offload(&self) -> Result<String, String> {
         let res = self.resources()?;
-        operations::llm_offload(res)
-            .await
-            .map_err(|e| e.to_string())?;
+        llm::llm_offload(res).await.map_err(|e| e.to_string())?;
         Ok("LLM offloaded".to_string())
     }
 
@@ -410,18 +421,16 @@ impl KoharuMcp {
         Parameters(p): Parameters<LlmGenerateParams>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        operations::llm_generate(
+        llm::llm_generate(
             res.clone(),
-            LlmGeneratePayload {
-                index: p.index,
-                text_block_index: p.text_block_index,
-                language: p.language,
-            },
+            &p.document_id,
+            p.text_block_index,
+            p.language.as_deref(),
         )
         .await
         .map_err(|e| e.to_string())?;
 
-        let doc = operations::get_document(res, IndexPayload { index: p.index })
+        let doc = io::get_document(res, &p.document_id)
             .await
             .map_err(|e| e.to_string())?;
 
@@ -446,21 +455,21 @@ impl KoharuMcp {
             .transpose()
             .map_err(|e: anyhow::Error| e.to_string())?;
 
-        operations::process(
+        let jobs = Arc::new(RwLock::new(HashMap::new()));
+        pipeline::process(
             res,
             ProcessRequest {
-                index: p.index,
-                llm_model_id: p.llm_model_id,
-                llm_api_key: None,
-                llm_base_url: None,
-                llm_temperature: None,
-                llm_max_tokens: None,
-                llm_custom_system_prompt: None,
+                document_id: p.document_id,
+                llm: p.llm_target.map(|target| PipelineLlmRequest {
+                    target,
+                    options: None,
+                }),
                 language: p.language,
                 shader_effect: effect,
                 shader_stroke: None,
                 font_family: p.font_family,
             },
+            jobs,
         )
         .await
         .map_err(|e| e.to_string())?;
@@ -476,9 +485,25 @@ impl KoharuMcp {
         Parameters(p): Parameters<UpdateTextBlockPayload>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        let info = operations::update_text_block(res, p)
-            .await
-            .map_err(|e| e.to_string())?;
+        let document_id = self.document_id_for_index(&res, p.index).await?;
+        let info = edit::update_text_block(
+            res,
+            &document_id,
+            edit::UpdateTextBlockArgs {
+                text_block_index: p.text_block_index,
+                translation: p.translation,
+                x: p.x,
+                y: p.y,
+                width: p.width,
+                height: p.height,
+                font_families: p.font_families,
+                font_size: p.font_size,
+                color: p.color,
+                shader_effect: p.shader_effect,
+            },
+        )
+        .await
+        .map_err(|e| e.to_string())?;
         serde_json::to_string_pretty(&info).map_err(|e| e.to_string())
     }
 
@@ -488,7 +513,8 @@ impl KoharuMcp {
         Parameters(p): Parameters<AddTextBlockPayload>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        let index = operations::add_text_block(res, p)
+        let document_id = self.document_id_for_index(&res, p.index).await?;
+        let index = edit::add_text_block(res, &document_id, p.x, p.y, p.width, p.height)
             .await
             .map_err(|e| e.to_string())?;
         Ok(format!("Added text block at index {index}"))
@@ -500,7 +526,8 @@ impl KoharuMcp {
         Parameters(p): Parameters<RemoveTextBlockPayload>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        let remaining = operations::remove_text_block(res, p)
+        let document_id = self.document_id_for_index(&res, p.index).await?;
+        let remaining = edit::remove_text_block(res, &document_id, p.text_block_index)
             .await
             .map_err(|e| e.to_string())?;
         Ok(format!("Removed text block. {remaining} remaining."))
@@ -512,7 +539,8 @@ impl KoharuMcp {
         Parameters(p): Parameters<MaskMorphPayload>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        operations::dilate_mask(res, p)
+        let document_id = self.document_id_for_index(&res, p.index).await?;
+        edit::dilate_mask(res, &document_id, p.radius)
             .await
             .map_err(|e| e.to_string())?;
         Ok("Dilated mask".to_string())
@@ -524,7 +552,8 @@ impl KoharuMcp {
         Parameters(p): Parameters<MaskMorphPayload>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        operations::erode_mask(res, p)
+        let document_id = self.document_id_for_index(&res, p.index).await?;
+        edit::erode_mask(res, &document_id, p.radius)
             .await
             .map_err(|e| e.to_string())?;
         Ok("Eroded mask".to_string())
@@ -536,16 +565,14 @@ impl KoharuMcp {
         Parameters(p): Parameters<InpaintRegionParams>,
     ) -> Result<String, String> {
         let res = self.resources()?;
-        operations::inpaint_partial(
+        edit::inpaint_partial(
             res,
-            InpaintPartialPayload {
-                index: p.index,
-                region: InpaintRegion {
-                    x: p.x,
-                    y: p.y,
-                    width: p.width,
-                    height: p.height,
-                },
+            &p.document_id,
+            Region {
+                x: p.x,
+                y: p.y,
+                width: p.width,
+                height: p.height,
             },
         )
         .await

koharu-rpc/src/shared.rs

@@ -1,20 +1,8 @@
-use std::future::Future;
-use std::pin::Pin;
 use std::sync::Arc;
 
 use koharu_app::AppResources;
-use koharu_core::BootstrapConfig;
 use koharu_runtime::RuntimeManager;
-use tokio::sync::{OnceCell, watch};
-
-pub type InitializeFuture = Pin<Box<dyn Future<Output = anyhow::Result<()>> + Send + 'static>>;
-
-#[derive(Clone)]
-pub struct BootstrapHooks {
-    pub get_config: Arc<dyn Fn() -> anyhow::Result<BootstrapConfig> + Send + Sync>,
-    pub put_config: Arc<dyn Fn(BootstrapConfig) -> anyhow::Result<BootstrapConfig> + Send + Sync>,
-    pub initialize: Arc<dyn Fn() -> InitializeFuture + Send + Sync>,
-}
+use tokio::sync::OnceCell;
 
 #[derive(Clone)]
 pub struct SharedState {
@@ -23,22 +11,13 @@ pub struct SharedState {
 
 struct Inner {
     resources: Arc<OnceCell<AppResources>>,
-    runtime: watch::Receiver<RuntimeManager>,
-    bootstrap: BootstrapHooks,
+    runtime: RuntimeManager,
 }
 
 impl SharedState {
-    pub fn new(
-        resources: Arc<OnceCell<AppResources>>,
-        runtime: watch::Receiver<RuntimeManager>,
-        bootstrap: BootstrapHooks,
-    ) -> Self {
+    pub fn new(resources: Arc<OnceCell<AppResources>>, runtime: RuntimeManager) -> Self {
         Self {
-            inner: Arc::new(Inner {
-                resources,
-                runtime,
-                bootstrap,
-            }),
+            inner: Arc::new(Inner { resources, runtime }),
         }
     }
 
@@ -46,41 +25,7 @@ impl SharedState {
         self.inner.resources.get().cloned()
     }
 
-    pub fn resources_cell(&self) -> Arc<OnceCell<AppResources>> {
-        Arc::clone(&self.inner.resources)
-    }
-
     pub fn runtime(&self) -> RuntimeManager {
-        self.inner.runtime.borrow().clone()
-    }
-
-    pub fn subscribe_runtime(&self) -> watch::Receiver<RuntimeManager> {
         self.inner.runtime.clone()
     }
-
-    pub async fn get_or_try_init<F, Fut>(&self, init: F) -> anyhow::Result<AppResources>
-    where
-        F: FnOnce() -> Fut,
-        Fut: Future<Output = anyhow::Result<AppResources>>,
-    {
-        Ok(self.inner.resources.get_or_try_init(init).await?.clone())
-    }
-
-    pub fn get_config(&self) -> anyhow::Result<BootstrapConfig> {
-        (self.inner.bootstrap.get_config)()
-    }
-
-    pub fn put_config(&self, config: BootstrapConfig) -> anyhow::Result<BootstrapConfig> {
-        (self.inner.bootstrap.put_config)(config)
-    }
-
-    pub async fn initialize(&self) -> anyhow::Result<()> {
-        (self.inner.bootstrap.initialize)().await
-    }
-}
-
-pub fn get_resources(shared: &SharedState) -> anyhow::Result<AppResources> {
-    shared
-        .get()
-        .ok_or_else(|| anyhow::anyhow!("Resources not initialized"))
 }

koharu-rpc/src/tracker.rs

@@ -1,10 +1,7 @@
 use std::{collections::HashMap, sync::Arc};
 
 use koharu_app::pipeline;
-use koharu_core::{
-    DownloadProgress, DownloadState, DownloadStatus, JobState, JobStatus, PipelineProgress,
-    PipelineStatus, PipelineStep, TransferStatus,
-};
+use koharu_core::{DownloadProgress, DownloadState, DownloadStatus, JobState, TransferStatus};
 use tokio::sync::RwLock;
 
 use crate::shared::SharedState;
@@ -16,23 +13,27 @@ pub struct Tracker {
 }
 
 struct Inner {
-    jobs: RwLock<HashMap<String, JobState>>,
+    jobs: pipeline::Jobs,
     downloads: RwLock<HashMap<String, DownloadState>>,
 }
 
 impl Tracker {
     pub fn new(shared: &SharedState) -> Self {
+        let jobs = Arc::new(RwLock::new(HashMap::new()));
         let inner = Arc::new(Inner {
-            jobs: RwLock::new(HashMap::new()),
+            jobs: jobs.clone(),
             downloads: RwLock::new(HashMap::new()),
         });
 
-        spawn_pipeline_listener(inner.clone());
         spawn_download_listener(inner.clone(), shared.clone());
 
         Self { inner }
     }
 
+    pub fn jobs(&self) -> pipeline::Jobs {
+        self.inner.jobs.clone()
+    }
+
     pub async fn list_jobs(&self) -> Vec<JobState> {
         let mut jobs: Vec<_> = self.inner.jobs.read().await.values().cloned().collect();
         jobs.sort_by(|a, b| a.id.cmp(&b.id));
@@ -48,19 +49,27 @@ impl Tracker {
     }
 
     pub async fn list_downloads(&self) -> Vec<DownloadState> {
-        let mut downloads: Vec<_> = self.inner.downloads.read().await.values().cloned().collect();
+        let mut downloads: Vec<_> = self
+            .inner
+            .downloads
+            .read()
+            .await
+            .values()
+            .cloned()
+            .collect();
         downloads.sort_by(|a, b| a.filename.cmp(&b.filename));
         downloads
     }
 }
 
-fn spawn_pipeline_listener(inner: Arc<Inner>) {
-    let mut rx = pipeline::subscribe();
+fn spawn_download_listener(inner: Arc<Inner>, shared: SharedState) {
     tokio::spawn(async move {
+        let mut download_rx = shared.runtime().subscribe_downloads();
+
         loop {
-            match rx.recv().await {
+            match download_rx.recv().await {
                 Ok(progress) => {
-                    update_job_state(&inner, pipeline_job_state(progress)).await;
+                    update_download_state(&inner, download_state(progress)).await;
                 }
                 Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => continue,
                 Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
@@ -69,36 +78,8 @@ fn spawn_pipeline_listener(inner: Arc<Inner>) {
     });
 }
 
-fn spawn_download_listener(inner: Arc<Inner>, shared: SharedState) {
-    tokio::spawn(async move {
-        let mut runtime_rx = shared.subscribe_runtime();
-        let mut download_rx = runtime_rx.borrow().clone().subscribe_downloads();
-
-        loop {
-            tokio::select! {
-                changed = runtime_rx.changed() => {
-                    if changed.is_err() {
-                        break;
-                    }
-                    inner.downloads.write().await.clear();
-                    download_rx = runtime_rx.borrow().clone().subscribe_downloads();
-                }
-                received = download_rx.recv() => match received {
-                    Ok(progress) => {
-                        update_download_state(&inner, download_state(progress)).await;
-                    }
-                    Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => continue,
-                    Err(tokio::sync::broadcast::error::RecvError::Closed) => {
-                        download_rx = runtime_rx.borrow().clone().subscribe_downloads();
-                    }
-                }
-            }
-        }
-    });
-}
-
 async fn update_job_state(inner: &Arc<Inner>, job: JobState) {
-    let terminal = !matches!(job.status, JobStatus::Running);
+    let terminal = !matches!(job.status, koharu_core::JobStatus::Running);
     let mut jobs = inner.jobs.write().await;
     if terminal {
         jobs.remove(&job.id);
@@ -120,32 +101,6 @@ async fn update_download_state(inner: &Arc<Inner>, download: DownloadState) {
     }
 }
 
-fn pipeline_job_state(progress: PipelineProgress) -> JobState {
-    let (status, error) = match progress.status {
-        PipelineStatus::Running => (JobStatus::Running, None),
-        PipelineStatus::Completed => (JobStatus::Completed, None),
-        PipelineStatus::Cancelled => (JobStatus::Cancelled, None),
-        PipelineStatus::Failed(message) => (JobStatus::Failed, Some(message)),
-    };
-
-    JobState {
-        id: progress.job_id,
-        kind: "pipeline".to_string(),
-        status,
-        step: progress.step.map(pipeline_step_name),
-        current_document: progress.current_document,
-        total_documents: progress.total_documents,
-        current_step_index: progress.current_step_index,
-        total_steps: progress.total_steps,
-        overall_percent: progress.overall_percent,
-        error,
-    }
-}
-
-fn pipeline_step_name(step: PipelineStep) -> String {
-    step.to_string()
-}
-
 fn download_state(progress: DownloadProgress) -> DownloadState {
     let (status, error) = match progress.status {
         DownloadStatus::Started => (TransferStatus::Started, None),
@@ -166,28 +121,7 @@ fn download_state(progress: DownloadProgress) -> DownloadState {
 
 #[cfg(test)]
 mod tests {
-    use koharu_core::{PipelineStatus, PipelineStep};
-
-    use super::{TransferStatus, download_state, pipeline_job_state};
-
-    #[test]
-    fn pipeline_progress_maps_to_job_state() {
-        let state = pipeline_job_state(koharu_core::PipelineProgress {
-            job_id: "job-1".to_string(),
-            status: PipelineStatus::Failed("boom".to_string()),
-            step: Some(PipelineStep::Render),
-            current_document: 1,
-            total_documents: 2,
-            current_step_index: 4,
-            total_steps: 5,
-            overall_percent: 80,
-        });
-
-        assert_eq!(state.id, "job-1");
-        assert_eq!(state.kind, "pipeline");
-        assert_eq!(state.step.as_deref(), Some("render"));
-        assert_eq!(state.error.as_deref(), Some("boom"));
-    }
+    use super::{TransferStatus, download_state};
 
     #[test]
     fn download_progress_maps_to_download_state() {

koharu-runtime/Cargo.toml

@@ -14,6 +14,7 @@ publish.workspace = true
 [dependencies]
 koharu-core = { workspace = true }
 anyhow = { workspace = true }
+camino = { workspace = true }
 dirs = { workspace = true }
 futures = { workspace = true }
 hf-hub = { workspace = true }

koharu-runtime/src/archive.rs

@@ -24,7 +24,7 @@ pub(crate) enum ExtractPolicy<'a> {
 pub(crate) async fn fetch(runtime: &Runtime, url: &str, file_name: &str) -> Result<PathBuf> {
     runtime
         .artifacts()
-        .cached_download(url, file_name, runtime.layout().downloads_root())
+        .cached_download(url, file_name, &runtime.layout().downloads_root)
         .await
         .with_context(|| format!("failed to download `{url}`"))
 }

koharu-runtime/src/artifacts.rs

@@ -57,7 +57,7 @@ impl ArtifactStore {
     }
 
     pub fn huggingface_path(&self, repo: &str, filename: &str) -> Result<PathBuf> {
-        huggingface_path(self.layout.huggingface_root(), repo, filename)
+        huggingface_path(&self.layout.huggingface_root, repo, filename)
     }
 
     pub(crate) async fn cached_download(

koharu-runtime/src/cuda.rs

@@ -207,7 +207,7 @@ fn driver_library_available() -> bool {
 }
 
 fn install_dir(runtime: &Runtime) -> std::path::PathBuf {
-    runtime.layout().runtime_package_dir("cuda")
+    runtime.layout().runtime_root.join("cuda")
 }
 
 fn platform_tags() -> Result<&'static [&'static str]> {

koharu-runtime/src/http.rs

@@ -5,8 +5,6 @@ use anyhow::Result;
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
 use reqwest_retry::{RetryTransientMiddleware, policies::ExponentialBackoff};
 
-use crate::Settings;
-
 const USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"));
 
 #[derive(Clone)]
@@ -15,10 +13,10 @@ pub(crate) struct HttpStack {
 }
 
 impl HttpStack {
-    pub(crate) fn new(settings: &Settings) -> Result<Self> {
+    pub(crate) fn new() -> Result<Self> {
         Ok(Self {
             client: Arc::new(
-                ClientBuilder::new(build_base_client(settings)?)
+                ClientBuilder::new(build_base_client()?)
                     .with(RetryTransientMiddleware::new_with_policy(retry_policy()))
                     .build(),
             ),
@@ -30,16 +28,12 @@ impl HttpStack {
     }
 }
 
-fn build_base_client(settings: &Settings) -> Result<reqwest::Client> {
-    let mut builder = reqwest::Client::builder()
+fn build_base_client() -> Result<reqwest::Client> {
+    let builder = reqwest::Client::builder()
         .user_agent(USER_AGENT)
         .connect_timeout(Duration::from_secs(20))
         .read_timeout(Duration::from_secs(60));
 
-    if let Some(proxy) = settings.http_proxy() {
-        builder = builder.proxy(reqwest::Proxy::all(proxy.as_str())?);
-    }
-
     Ok(builder.build()?)
 }