@minimalcorp/tsunagi 0.1.37 → 0.1.39

package/dist/server/lib/local-llm-env.js

@@ -0,0 +1,91 @@
+import { prisma } from './db.js';
+/**
+ * ローカルLLM（Ollama / LM Studio）の Anthropic 互換 API で Claude Code を動かすための共通処理。
+ */
+const ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** ローカルLLMタブでは Anthropic の認証情報を環境変数ごと取り除く（ANTHROPIC_AUTH_TOKEN と競合するため） */
+export const LOCAL_LLM_UNSET_ENV_KEYS = ['ANTHROPIC_API_KEY', 'CLAUDE_CODE_OAUTH_TOKEN'];
+/** AppSetting から JSON 設定を読む。未保存・破損時は既定値 */
+export async function readAppSetting(key, defaults) {
+    const row = await prisma.appSetting.findUnique({ where: { key } });
+    if (!row)
+        return defaults;
+    try {
+        return { ...defaults, ...JSON.parse(row.value) };
+    }
+    catch {
+        return defaults;
+    }
+}
+export async function writeAppSetting(key, settings) {
+    const value = JSON.stringify(settings);
+    await prisma.appSetting.upsert({ where: { key }, create: { key, value }, update: { value } });
+    return settings;
+}
+/** http(s) の URL を末尾スラッシュなしに正規化する。不正なら null */
+export function normalizeBaseUrl(value) {
+    const baseUrl = typeof value === 'string' ? value.trim().replace(/\/+$/, '') : '';
+    try {
+        const url = new URL(baseUrl);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return baseUrl;
+}
+export function parseContextTokens(value) {
+    const n = Number(value);
+    return Number.isInteger(n) && n > 0 ? n : null;
+}
+/** extraEnv を検証する。不正ならエラーメッセージ */
+export function parseExtraEnv(value) {
+    const env = {};
+    if (value === undefined)
+        return { env };
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return { error: 'extraEnv must be an object' };
+    }
+    for (const [key, v] of Object.entries(value)) {
+        if (!ENV_KEY_PATTERN.test(key))
+            return { error: `Invalid env key: ${key}` };
+        if (typeof v !== 'string')
+            return { error: `Env value must be string: ${key}` };
+        env[key] = v;
+    }
+    return { env };
+}
+/**
+ * ローカルLLMタブの Claude Code が名乗るモデル名。tsunagi の中継口が使用中のモデルに書き換えるため、
+ * タブを作った後にモデルを切り替えても既存タブがそのまま追従する。
+ */
+export const LOCAL_MODEL_ALIAS = 'tsunagi-local';
+/**
+ * ローカルLLMタブの Claude Code を tsunagi の中継口に向けるための環境変数。
+ * DB の環境変数より後に適用し、同名キーを上書きする。
+ */
+export function buildLocalLlmEnv(params) {
+    const { proxyUrl, contextTokens, extraEnv } = params;
+    return {
+        ANTHROPIC_BASE_URL: proxyUrl,
+        // 中継口は値を検証しないが、未設定だと Claude Code がログインを要求する
+        ANTHROPIC_AUTH_TOKEN: 'tsunagi',
+        ANTHROPIC_MODEL: LOCAL_MODEL_ALIAS,
+        // opus / sonnet / haiku 等の別名はあえて割り当てない。中継口がどのモデル名でも使用中のモデルに
+        // 書き換えるため不要で、割り当てると `/model sonnet` が同じモデルへの切り替えとみなされ、
+        // PreModelSwitch フックを通らずに ~/.claude/settings.json へ保存されてしまう
+        CLAUDE_CODE_SUBAGENT_MODEL: LOCAL_MODEL_ALIAS,
+        // 未知のモデルは 200k 扱いになり auto-compact が効かないため、ローカル側の値に揃える
+        CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(contextTokens),
+        // リクエスト毎に変わる attribution がローカル側の KV キャッシュを無効化するため外す
+        CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+        // ローカルLLMはプロンプト読み込み中(数分)にバイトを返さないため、既定の 5 分の
+        // 無通信タイムアウト / stream watchdog で打ち切られ再送される。上限(30分)まで延ばす
+        API_FORCE_IDLE_TIMEOUT: '0',
+        CLAUDE_STREAM_IDLE_TIMEOUT_MS: '1800000',
+        API_TIMEOUT_MS: '3600000',
+        ...extraEnv,
+    };
+}

package/dist/server/lib/local-llm.d.ts

@@ -0,0 +1,56 @@
+import type { LocalLlmModel, LocalLlmModelRef, LocalLlmSettings, LocalLlmStatus } from '@minimalcorp/tsunagi-shared';
+export declare function defaultLocalLlmSettings(): LocalLlmSettings;
+export declare function getLocalLlmSettings(): Promise<LocalLlmSettings>;
+export declare function saveLocalLlmSettings(settings: LocalLlmSettings): Promise<LocalLlmSettings>;
+/** リクエストボディを検証して LocalLlmSettings に正規化する。不正ならエラーメッセージを返す */
+export declare function parseLocalLlmSettings(body: unknown): {
+    settings: LocalLlmSettings;
+} | {
+    error: string;
+};
+/** ローカルLLMタブを起動できる状態か（オンボーディング完了判定にも使う） */
+export declare function isLocalLlmReady(): Promise<boolean>;
+/** 有効なプロバイダーのダウンロード済みモデル。取得に失敗したプロバイダーはエラーとして返す */
+export declare function listLocalLlmModels(): Promise<{
+    models: LocalLlmModel[];
+    errors: Array<{
+        provider: LocalLlmModelRef['provider'];
+        message: string;
+    }>;
+}>;
+/** 中継口の転送先 */
+export interface LocalLlmTarget {
+    baseUrl: string;
+    /** 転送時に付ける認証トークン */
+    authToken: string;
+    /** リクエストの model に入れる名前（Ollama はコンテキスト長を焼き込んだ派生モデル） */
+    runModel: string;
+}
+/** 指定したプロバイダーのモデルを全部解放する（プロバイダーを無効化する前に使う） */
+export declare function unloadProvider(provider: LocalLlmModelRef['provider']): Promise<void>;
+/**
+ * 使用中のモデルを読み込み（他のモデルは全部解放し）、中継口の転送先を返す。
+ * 読み込み済みなら何もしない。設定の不備はそのまま例外にする（タブにエラーとして表示される）。
+ */
+export declare function ensureActiveLoaded(): Promise<LocalLlmTarget>;
+/** すべてのモデルを解放する（Settings の解放ボタン・自動解放・tsunagi 終了時） */
+export declare function unloadAll(): Promise<void>;
+/** 中継口がリクエストを受け付けたとき */
+export declare function beginRequest(): void;
+/** 中継口のリクエストが終わったとき（成功・失敗・中断のいずれも） */
+export declare function endRequest(): void;
+export declare function getInflight(): number;
+export declare function getLocalLlmStatus(): Promise<LocalLlmStatus>;
+/**
+ * 使用中のモデルを切り替える。応答生成中のタブがあれば切り替えない（生成中のモデルを外すと壊れるため）。
+ * 読み込みは待たずに始める（状態は getLocalLlmStatus で確認する）。
+ */
+export declare function activate(next: LocalLlmSettings): Promise<{
+    ok: true;
+    settings: LocalLlmSettings;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** tsunagi 終了時（設定で有効なら）にモデルを解放する。終了を妨げないよう上限時間を設ける */
+export declare function unloadOnShutdown(timeoutMs?: number): Promise<void>;

package/dist/server/lib/local-llm.js

@@ -0,0 +1,366 @@
+import { prisma } from './db.js';
+import { parseContextTokens, parseExtraEnv, readAppSetting, writeAppSetting, } from './local-llm-env.js';
+import { OLLAMA_SETTING_KEY, ensureOllamaContextModel, getOllamaSettings, getOllamaStatus, listOllamaModels, loadOllamaModel, ollamaContextModelName, unloadOllamaModel, } from './ollama-settings.js';
+import { LMSTUDIO_SETTING_KEY, getLmStudioSettings, getLmStudioStatus, listLmStudioModels, lmStudioAuthToken, loadLmStudioModel, unloadLmStudioModel, } from './lmstudio.js';
+/**
+ * ローカルLLM（Ollama / LM Studio）の「使用中のモデル」を管理する。
+ * 一般的なマシンでは 20〜30GB 級のモデルを2つ同時に載せられないため、メモリに載せるモデルは
+ * プロバイダーをまたいで常に1つにする。ローカルLLMタブのリクエストは tsunagi の中継口を通り、
+ * ここで使用中のモデルを読み込んで（他は全部解放して）から転送される。
+ */
+const SETTING_KEY = 'local-llm';
+export function defaultLocalLlmSettings() {
+    return {
+        active: null,
+        idleUnloadMinutes: 15,
+        unloadOnExit: true,
+        webSearch: 'local',
+        extraEnv: {},
+    };
+}
+/**
+ * 旧形式（Ollama / LM Studio の設定ごとにモデルを持っていた）からの移行。
+ * local-llm の設定がまだなく、旧 Ollama 設定にモデルがあればそれを使用中のモデルにする。
+ */
+async function migrateLegacySettings() {
+    const settings = defaultLocalLlmSettings();
+    const rows = await prisma.appSetting.findMany({
+        where: { key: { in: [OLLAMA_SETTING_KEY, LMSTUDIO_SETTING_KEY] } },
+    });
+    for (const row of rows) {
+        let legacy;
+        try {
+            legacy = JSON.parse(row.value);
+        }
+        catch {
+            continue;
+        }
+        if (settings.active || legacy.enabled !== true || typeof legacy.model !== 'string')
+            continue;
+        if (!legacy.model)
+            continue;
+        settings.active = {
+            provider: row.key === OLLAMA_SETTING_KEY ? 'ollama' : 'lmstudio',
+            model: legacy.model,
+            contextTokens: parseContextTokens(legacy.contextTokens) ?? 65536,
+        };
+        const extraEnv = parseExtraEnv(legacy.extraEnv);
+        if ('env' in extraEnv)
+            settings.extraEnv = extraEnv.env;
+        if (legacy.webSearch === 'ollama')
+            settings.webSearch = 'ollama';
+    }
+    return settings;
+}
+export async function getLocalLlmSettings() {
+    const row = await prisma.appSetting.findUnique({ where: { key: SETTING_KEY } });
+    if (!row)
+        return migrateLegacySettings();
+    return readAppSetting(SETTING_KEY, defaultLocalLlmSettings());
+}
+export async function saveLocalLlmSettings(settings) {
+    return writeAppSetting(SETTING_KEY, settings);
+}
+/** リクエストボディを検証して LocalLlmSettings に正規化する。不正ならエラーメッセージを返す */
+export function parseLocalLlmSettings(body) {
+    if (typeof body !== 'object' || body === null)
+        return { error: 'Invalid body' };
+    const b = body;
+    let active = null;
+    if (b.active !== null && b.active !== undefined) {
+        const a = b.active;
+        if (a.provider !== 'ollama' && a.provider !== 'lmstudio') {
+            return { error: 'active.provider must be "ollama" or "lmstudio"' };
+        }
+        if (typeof a.model !== 'string' || !a.model.trim()) {
+            return { error: 'active.model must be a non-empty string' };
+        }
+        const contextTokens = parseContextTokens(a.contextTokens);
+        if (!contextTokens)
+            return { error: 'active.contextTokens must be a positive integer' };
+        active = { provider: a.provider, model: a.model.trim(), contextTokens };
+    }
+    const idleUnloadMinutes = Number(b.idleUnloadMinutes);
+    if (!Number.isInteger(idleUnloadMinutes) || idleUnloadMinutes < 0) {
+        return { error: 'idleUnloadMinutes must be a non-negative integer' };
+    }
+    if (typeof b.unloadOnExit !== 'boolean')
+        return { error: 'unloadOnExit must be boolean' };
+    if (b.webSearch !== 'local' && b.webSearch !== 'ollama') {
+        return { error: 'webSearch must be "local" or "ollama"' };
+    }
+    const extraEnv = parseExtraEnv(b.extraEnv);
+    if ('error' in extraEnv)
+        return extraEnv;
+    return {
+        settings: {
+            active,
+            idleUnloadMinutes,
+            unloadOnExit: b.unloadOnExit,
+            webSearch: b.webSearch,
+            extraEnv: extraEnv.env,
+        },
+    };
+}
+/** ローカルLLMタブを起動できる状態か（オンボーディング完了判定にも使う） */
+export async function isLocalLlmReady() {
+    const { active } = await getLocalLlmSettings();
+    if (!active)
+        return false;
+    const provider = active.provider === 'ollama' ? await getOllamaSettings() : await getLmStudioSettings();
+    return provider.enabled;
+}
+/** 有効なプロバイダーのダウンロード済みモデル。取得に失敗したプロバイダーはエラーとして返す */
+export async function listLocalLlmModels() {
+    const [ollama, lmstudio] = await Promise.all([getOllamaSettings(), getLmStudioSettings()]);
+    const models = [];
+    const errors = [];
+    const tasks = [];
+    if (ollama.enabled) {
+        tasks.push(listOllamaModels(ollama.baseUrl)
+            .then((list) => void models.push(...list))
+            .catch((e) => void errors.push({ provider: 'ollama', message: errorMessage(e) })));
+    }
+    if (lmstudio.enabled) {
+        tasks.push(listLmStudioModels(lmstudio)
+            .then((list) => void models.push(...list))
+            .catch((e) => void errors.push({ provider: 'lmstudio', message: errorMessage(e) })));
+    }
+    await Promise.all(tasks);
+    return { models, errors };
+}
+// ---- 読み込み・解放（同時に走らないよう直列化する） ----
+let queue = Promise.resolve();
+function serialize(task) {
+    const run = queue.catch(() => undefined).then(task);
+    queue = run;
+    return run;
+}
+let loading = false;
+let lastError;
+let inflight = 0;
+let idleTimer = null;
+let idleUnloadAt = null;
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Ollama で使用中のモデルを表す名前（派生モデル）。keep は解放しない */
+function ollamaKeepName(active) {
+    return active?.provider === 'ollama'
+        ? ollamaContextModelName(active.model, active.contextTokens)
+        : null;
+}
+/**
+ * keep 以外のモデルを、有効なすべてのプロバイダーで解放する（keep が null なら全部）。
+ * LM Studio の keep は、設定のコンテキスト長以上で読み込まれているインスタンスだけ残す。
+ */
+async function unloadOthers(keep) {
+    const [ollama, lmstudio] = await Promise.all([getOllamaSettings(), getLmStudioSettings()]);
+    if (ollama.enabled) {
+        const status = await getOllamaStatus(ollama.baseUrl);
+        const keepName = ollamaKeepName(keep);
+        for (const loaded of status.loaded) {
+            if (loaded.name !== keepName)
+                await unloadOllamaModel(ollama.baseUrl, loaded.name);
+        }
+    }
+    if (lmstudio.enabled) {
+        const status = await getLmStudioStatus(lmstudio);
+        for (const loaded of status.loaded) {
+            const isKeep = keep?.provider === 'lmstudio' &&
+                loaded.key === keep.model &&
+                loaded.contextLength >= keep.contextTokens;
+            if (!isKeep)
+                await unloadLmStudioModel(lmstudio, loaded.instanceId);
+        }
+    }
+}
+/** 指定したプロバイダーのモデルを全部解放する（プロバイダーを無効化する前に使う） */
+export function unloadProvider(provider) {
+    return serialize(async () => {
+        if (provider === 'ollama') {
+            const ollama = await getOllamaSettings();
+            const status = await getOllamaStatus(ollama.baseUrl);
+            for (const loaded of status.loaded)
+                await unloadOllamaModel(ollama.baseUrl, loaded.name);
+        }
+        else {
+            const lmstudio = await getLmStudioSettings();
+            const status = await getLmStudioStatus(lmstudio);
+            for (const loaded of status.loaded) {
+                await unloadLmStudioModel(lmstudio, loaded.instanceId);
+            }
+        }
+    });
+}
+/** 使用中のモデルがメモリにあるか（読み込み済みなら転送先を返す） */
+async function findLoadedTarget(active) {
+    if (active.provider === 'ollama') {
+        const ollama = await getOllamaSettings();
+        const status = await getOllamaStatus(ollama.baseUrl);
+        return status.loaded.some((l) => l.name === ollamaKeepName(active));
+    }
+    const lmstudio = await getLmStudioSettings();
+    const status = await getLmStudioStatus(lmstudio);
+    return status.loaded.some((l) => l.key === active.model && l.contextLength >= active.contextTokens);
+}
+/**
+ * 使用中のモデルを読み込み（他のモデルは全部解放し）、中継口の転送先を返す。
+ * 読み込み済みなら何もしない。設定の不備はそのまま例外にする（タブにエラーとして表示される）。
+ */
+export function ensureActiveLoaded() {
+    return serialize(async () => {
+        const { active } = await getLocalLlmSettings();
+        if (!active) {
+            throw new Error('ローカルLLMのモデルが未設定です。Settings で使用するモデルを選んでください');
+        }
+        loading = true;
+        try {
+            const target = await loadActive(active);
+            lastError = undefined;
+            return target;
+        }
+        catch (error) {
+            lastError = errorMessage(error);
+            throw error;
+        }
+        finally {
+            loading = false;
+        }
+    });
+}
+async function loadActive(active) {
+    if (active.provider === 'ollama') {
+        const ollama = await getOllamaSettings();
+        if (!ollama.enabled)
+            throw new Error('Ollama が無効です。Settings で有効にしてください');
+        const runModel = await ensureOllamaContextModel(ollama.baseUrl, active.model, active.contextTokens);
+        await unloadOthers(active);
+        if (!(await findLoadedTarget(active)))
+            await loadOllamaModel(ollama.baseUrl, runModel);
+        return { baseUrl: ollama.baseUrl, authToken: 'ollama', runModel };
+    }
+    const lmstudio = await getLmStudioSettings();
+    if (!lmstudio.enabled)
+        throw new Error('LM Studio が無効です。Settings で有効にしてください');
+    const status = await getLmStudioStatus(lmstudio);
+    if (!status.serverRunning) {
+        throw new Error('LM Studio のサーバーが起動していません。Settings（LM Studio）か LM Studio アプリの Developer タブから起動してください');
+    }
+    await unloadOthers(active);
+    if (!(await findLoadedTarget(active))) {
+        // MLX はモデルの最大値で読み込まれる（KV キャッシュが動的なため）
+        await loadLmStudioModel(lmstudio, active.model, active.contextTokens);
+    }
+    return {
+        baseUrl: lmstudio.baseUrl,
+        authToken: lmStudioAuthToken(lmstudio),
+        runModel: active.model,
+    };
+}
+/** すべてのモデルを解放する（Settings の解放ボタン・自動解放・tsunagi 終了時） */
+export function unloadAll() {
+    // 解放済みになるので、予約済みの自動解放は不要になる
+    clearIdleTimer();
+    return serialize(async () => {
+        await unloadOthers(null);
+    });
+}
+// ---- 中継口のリクエスト数と自動解放 ----
+function clearIdleTimer() {
+    if (idleTimer)
+        clearTimeout(idleTimer);
+    idleTimer = null;
+    idleUnloadAt = null;
+}
+async function scheduleIdleUnload() {
+    clearIdleTimer();
+    const { idleUnloadMinutes } = await getLocalLlmSettings();
+    // 待っている間に次のリクエストが始まっていれば予約しない
+    if (idleUnloadMinutes === 0 || inflight > 0)
+        return;
+    const ms = idleUnloadMinutes * 60 * 1000;
+    idleUnloadAt = new Date(Date.now() + ms);
+    idleTimer = setTimeout(() => {
+        idleTimer = null;
+        idleUnloadAt = null;
+        if (inflight > 0)
+            return;
+        unloadAll().catch((error) => {
+            lastError = `自動解放に失敗しました: ${errorMessage(error)}`;
+        });
+    }, ms);
+}
+/** 中継口がリクエストを受け付けたとき */
+export function beginRequest() {
+    inflight += 1;
+    clearIdleTimer();
+}
+/** 中継口のリクエストが終わったとき（成功・失敗・中断のいずれも） */
+export function endRequest() {
+    inflight = Math.max(0, inflight - 1);
+    if (inflight === 0)
+        void scheduleIdleUnload();
+}
+export function getInflight() {
+    return inflight;
+}
+export async function getLocalLlmStatus() {
+    const { active } = await getLocalLlmSettings();
+    const base = {
+        active,
+        inflight,
+        idleUnloadAt: idleUnloadAt ? idleUnloadAt.toISOString() : null,
+    };
+    if (!active)
+        return { ...base, state: 'unconfigured' };
+    if (loading)
+        return { ...base, state: 'loading' };
+    try {
+        if (await findLoadedTarget(active))
+            return { ...base, state: 'loaded' };
+    }
+    catch (error) {
+        return { ...base, state: 'error', error: errorMessage(error) };
+    }
+    return lastError ? { ...base, state: 'error', error: lastError } : { ...base, state: 'unloaded' };
+}
+/**
+ * 使用中のモデルを切り替える。応答生成中のタブがあれば切り替えない（生成中のモデルを外すと壊れるため）。
+ * 読み込みは待たずに始める（状態は getLocalLlmStatus で確認する）。
+ */
+export async function activate(next) {
+    const current = await getLocalLlmSettings();
+    const changed = JSON.stringify(current.active) !== JSON.stringify(next.active);
+    if (changed && inflight > 0) {
+        return {
+            ok: false,
+            error: '応答を生成中のタブがあるため、モデルを切り替えられません。完了してから切り替えてください',
+        };
+    }
+    const settings = await saveLocalLlmSettings(next);
+    if (changed) {
+        lastError = undefined;
+        if (settings.active) {
+            ensureActiveLoaded().catch(() => undefined);
+        }
+        else {
+            unloadAll().catch(() => undefined);
+        }
+    }
+    // 自動解放の時間が変わった場合に予約し直す
+    if (inflight === 0 && idleTimer)
+        void scheduleIdleUnload();
+    return { ok: true, settings };
+}
+/** tsunagi 終了時（設定で有効なら）にモデルを解放する。終了を妨げないよう上限時間を設ける */
+export async function unloadOnShutdown(timeoutMs = 10000) {
+    clearIdleTimer();
+    const { unloadOnExit } = await getLocalLlmSettings().catch(() => defaultLocalLlmSettings());
+    if (!unloadOnExit)
+        return;
+    await Promise.race([
+        unloadAll().catch(() => undefined),
+        new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+    ]);
+}

package/dist/server/lib/ollama-settings.d.ts

@@ -1,6 +1,5 @@
-import type { OllamaAccountStatus, OllamaSettings } from '@minimalcorp/tsunagi-shared';
-/** Ollama タブでは Anthropic の認証情報を環境変数ごと取り除く（ANTHROPIC_AUTH_TOKEN と競合するため） */
-export declare const OLLAMA_UNSET_ENV_KEYS: string[];
+import type { LocalLlmModel, OllamaAccountStatus, OllamaSettings, OllamaStatus } from '@minimalcorp/tsunagi-shared';
+export declare const OLLAMA_SETTING_KEY = "ollama";
 export declare function defaultOllamaSettings(): OllamaSettings;
 export declare function getOllamaSettings(): Promise<OllamaSettings>;
 export declare function saveOllamaSettings(settings: OllamaSettings): Promise<OllamaSettings>;
@@ -10,18 +9,25 @@ export declare function parseOllamaSettings(body: unknown): {
 } | {
     error: string;
 };
-/** Ollama タブを起動できる状態か（オンボーディング完了判定にも使う） */
-export declare function isOllamaReady(settings: OllamaSettings): boolean;
 /**
- * Ollama の Anthropic 互換 API で Claude Code を動かすための環境変数。
- * DB の環境変数より後に適用し、同名キーを上書きする。
+ * コンテキスト長を固定した派生モデルの名前（例: qwen3.6:35b-a3b → qwen3.6:35b-a3b-tsunagi-ctx65536）。
+ * Anthropic 互換 API ではリクエスト毎に num_ctx を渡せず、Ollama 全体の既定値（VRAM 24GiB 未満は 4k）
+ * が使われるため、num_ctx を焼き込んだモデルを作ってそれを使う。
  */
-export declare function buildOllamaEnv(settings: OllamaSettings): Record<string, string>;
+export declare function ollamaContextModelName(model: string, contextTokens: number): string;
+/** 派生モデルがなければ作る（重みは元モデルの blob を共有するため数秒で終わる）。作ったモデル名を返す */
+export declare function ensureOllamaContextModel(baseUrl: string, model: string, contextTokens: number): Promise<string>;
+/** モデルをメモリに読み込む（空のプロンプトで generate すると読み込みだけ行われる） */
+export declare function loadOllamaModel(baseUrl: string, name: string): Promise<void>;
+/** モデルをメモリから外す */
+export declare function unloadOllamaModel(baseUrl: string, name: string): Promise<void>;
 /**
  * Ollama の ollama.com サインイン状態を取得する。
  * Claude Code の WebSearch（web_search サーバーツール）は Ollama が ollama.com の Web 検索 API で
  * 代行するが、未サインインだと 401 になり `web_search_tool_result_error: unavailable` が返る。
  */
 export declare function getOllamaAccount(baseUrl: string): Promise<OllamaAccountStatus>;
-/** Ollama に pull 済みのモデル名一覧を取得する */
-export declare function listOllamaModels(baseUrl: string): Promise<string[]>;
+/** Ollama に pull 済みのモデル一覧を取得する（tsunagi が作った派生モデルは除く） */
+export declare function listOllamaModels(baseUrl: string): Promise<LocalLlmModel[]>;
+/** Ollama サーバーの接続可否・バージョン・読み込み中のモデル */
+export declare function getOllamaStatus(baseUrl: string): Promise<OllamaStatus>;