@aalis/plugin-llm-ollama 0.12.1 → 0.14.0

package/dist/index.js

@@ -1,10 +1,13 @@
-import { LLMCapabilities, llm } from '@aalis/api-llm';
-import { createProcessGateway, processService } from '@aalis/api-process';
-import { config, definePlugin, lifecycle, logger, optional, provide } from '@aalis/core';
+import { finishReasonOf, IDLE_TIMEOUT_MAX_MS, idleTimeout, LLMCapabilities, llm, metered, requestedThinking, } from '@aalis/api-llm';
+import { processService } from '@aalis/api-process';
+import { config, definePlugin, events, lifecycle, logger, optional, provide, } from '@aalis/core';
 import { configError, defineConfig, missingConfigError, parseConfig } from '@aalis/schema-config';
+import { TextError, textClauses, textOf, toSource } from '@aalis/schema-i18n';
 import { prepareLLMMessages, toLLMRole } from '@aalis/schema-message';
 import { safeFetch } from '@aalis/util-network-guard';
 import { truncateChars } from '@aalis/util-text-normalize';
+import { Agent, errors } from 'undici';
+import { t } from './texts.js';
 // ===== 插件元数据 =====
 /** 远程图片/音频下载硬上限（附件缓存默认 10MiB 且可配；此处是缓存失败回退直下时的兜底硬顶）。 */
 const MAX_REMOTE_BINARY_BYTES = 20 * 1024 * 1024;
@@ -15,51 +18,45 @@ function bodyExcerpt(body) {
     return truncateChars(body.replace(/\s+/g, ' ').trim(), ERROR_BODY_MAX_CHARS, '…');
 }
 /**
- * 读配置时校验 baseUrl，解析不了的与带用户名或密码的抛配置错误。带凭据的 URL fetch 拒发，凭据还会随报错与
- * 条目名称（WebUI 的模型下拉）显示出来；解析不了的无从判断有没有凭据，请求同样发不出去。消息不带 URL
+ * 读配置时校验 baseUrl，解析不了的、带查询串或片段的与带用户名或密码的抛配置错误。插件在 baseUrl 后面拼路径，带查询串或
+ * 片段时路径落进查询串或片段，请求地址是坏的；末尾只有一个 ? 时解析后查询串为空，拼出来照样是坏的，所以按原文判。带凭据
+ * 的 URL fetch 拒发，凭据还会随报错与条目名称（WebUI 的模型下拉）显示出来；解析不了的无从判断有没有凭据，请求同样发不
+ * 出去。消息不带 URL
  */
 function checkBaseUrl(baseUrl) {
     if (!URL.canParse(baseUrl)) {
-        throw configError('baseUrl 不是有效的 URL，需写成完整地址，如 http://localhost:11434');
+        throw configError(t('baseUrlInvalid'));
+    }
+    if (/[?#]/.test(baseUrl)) {
+        throw configError(t('baseUrlQuery'));
     }
     const { username, password } = new URL(baseUrl);
     if (username || password) {
-        throw configError('baseUrl 不能带用户名或密码（user:pass@），本插件不支持带凭据访问 Ollama');
+        throw configError(t('baseUrlCredentials'));
     }
 }
 /**
- * 错误信息与日志里显示的 URL：去掉查询串。没有查询串时原样返回，保留配置里的写法。带用户名或密码的 baseUrl
- * 读配置时已拒绝（见 checkBaseUrl）
- */
-function redactUrl(url) {
-    const parsed = new URL(url);
-    if (!parsed.search)
-        return url;
-    parsed.search = '';
-    return parsed.href;
-}
-/**
- * 错误消息连同底层原因，写成一行。fetch 网络失败的消息固定是「fetch failed」，真实原因（DNS、拒绝连接、TLS）在
- * cause 上；连 localhost 时两个地址族都失败，cause 是消息为空的 AggregateError，原因在它的子错误上
+ * 错误连同底层原因，写成一行（日志取 toSource）。fetch 网络失败的消息固定是「fetch failed」，真实原因（DNS、拒绝连接、TLS）
+ * 在 cause 上；连 localhost 时两个地址族都失败，cause 是消息为空的 AggregateError，原因在它的子错误上
  */
 function describeError(err) {
     const cause = err instanceof Error ? err.cause : undefined;
     const reasons = cause instanceof AggregateError ? cause.errors : cause instanceof Error ? [cause] : [];
     const detail = reasons.map(e => (e instanceof Error ? e.message : String(e))).join('; ');
-    return `${err instanceof Error ? err.message : String(err)}${detail ? ` ← ${detail}` : ''}`;
+    return detail ? t('withCause', { error: textOf(err), detail }) : textOf(err);
 }
 /** 常见状态码的一句提示 */
 function statusHint(status) {
     if (status === 401 || status === 403)
-        return '密钥无效或没有权限';
+        return t('hintAuth');
     if (status === 402)
-        return '余额不足或需要付费';
+        return t('hintPayment');
     if (status === 404)
-        return '模型或地址不对';
+        return t('hintNotFound');
     if (status === 429)
-        return '请求过多或额度不足';
+        return t('hintRateLimit');
     if (status >= 500)
-        return '上游服务故障';
+        return t('hintUpstream');
     return undefined;
 }
 /**
@@ -85,7 +82,10 @@ function upstreamMessage(body) {
 function httpErrorMessage(provider, status, body) {
     const hint = statusHint(status);
     const message = upstreamMessage(body);
-    return `${provider} API 错误 (${status})${hint ? `：${hint}` : ''}；${message ? `上游说明：${message}` : '详情见日志'}`;
+    return textClauses([
+        hint ? t('apiErrorHint', { provider, status, hint }) : t('apiError', { provider, status }),
+        message ? t('upstreamMessage', { message }) : t('seeLogs'),
+    ]);
 }
 /**
  * 流式读取响应体并限额：Content-Length 头超限即拒；流式累计超限即断，返回 null。
@@ -117,63 +117,77 @@ export async function readBodyCapped(res, maxBytes) {
     }
     return Buffer.concat(chunks);
 }
+/** 报告了思考能力的模型允许的档位：开关型，翻成 think 开关 */
+const THINKING_LEVELS = [
+    { id: 'off', label: t('levelOff') },
+    { id: 'on', label: t('levelOn') },
+];
 const configSchema = defineConfig({
     baseUrl: {
         type: 'string',
-        label: 'Ollama 地址',
+        label: t('baseUrlLabel'),
         default: 'http://localhost:11434',
         onInvalid: 'error',
-        description: '本地 Ollama 服务的 HTTP 地址',
+        description: t('baseUrlDescription'),
     },
     customModels: {
         type: 'textarea',
-        label: '自定义模型',
+        label: t('customModelsLabel'),
         default: '',
-        description: '手动添加的模型名称（每行一个或逗号分隔）。用于补充自动发现列表中未出现的模型。与自动发现重复时会提示去重。',
+        description: t('customModelsDescription'),
     },
     discoverModels: {
         type: 'boolean',
-        label: '自动发现模型',
+        label: t('discoverModelsLabel'),
         default: true,
-        description: '启动时请求 /api/tags 发现已安装的模型，WebUI 可刷新模型列表。服务不提供 /api/tags 时关闭：不发发现请求，只注册 customModels（此时必填），也不支持刷新。',
+        description: t('discoverModelsDescription'),
     },
     modelCapabilities: {
         type: 'textarea',
-        label: '单模型能力覆盖',
+        label: t('modelCapabilitiesLabel'),
         default: '',
-        description: '强制覆盖某模型的能力(优先级最高,高于 /api/show 自动探测与家族表),与 adapter 默认能力取并集。\n格式：`<modelId>: <cap1>,<cap2>,...`，每行一条。如：nemotron3:33b: chat,vision,tool_calling',
+        description: t('modelCapabilitiesDescription'),
     },
     providerCapabilities: {
         type: 'string',
-        label: '适配器默认能力（逗号分隔）',
+        label: t('providerCapabilitiesLabel'),
         default: '',
-        description: '兜底默认能力:仅当某模型既无法从 Ollama /api/show 探测、又不在内置家族表时才使用。能力现已自动探测,通常留空即可（填了反而可能给不支持的模型乱标能力）。例：chat,tool_calling,streaming',
+        description: t('providerCapabilitiesDescription'),
     },
     timeout: {
         type: 'number',
-        label: '请求超时 (秒)',
+        label: t('timeoutLabel'),
         default: 120,
-        description: 'LLM 请求超时时间（秒）。大模型或长上下文建议适当调大。0 = 不限制。',
+        description: t('timeoutDescription'),
     },
-    temperature: { type: 'number', label: '温度', default: 0.7, description: '0-2，越高越随机' },
+    temperature: { type: 'number', label: t('temperatureLabel'), default: 0.7, description: t('temperatureDescription') },
     maxTokens: {
         type: 'number',
-        label: '最大 Token',
+        label: t('maxTokensLabel'),
         default: 4096,
-        description: '单次回复最大生成 token 数（num_predict）',
+        min: 1,
+        integer: true,
+        onInvalid: 'error',
+        description: t('maxTokensDescription'),
+    },
+    contextLength: {
+        type: 'number',
+        label: t('contextLengthLabel'),
+        default: 8192,
+        description: t('contextLengthDescription'),
     },
-    contextLength: { type: 'number', label: '上下文长度', default: 8192, description: '模型上下文窗口大小（num_ctx）' },
     keepAlive: {
         type: 'string',
-        label: '模型保活时间',
+        label: t('keepAliveLabel'),
         default: '5m',
-        description: '模型在显存中保留的时间，如 5m、1h、0（立即卸载）',
+        description: t('keepAliveDescription'),
     },
     thinking: {
-        type: 'boolean',
-        label: '启用思考',
-        default: true,
-        description: '为支持思考的模型启用扩展思考（think 参数）。无 thinking 能力的模型该参数无效。',
+        type: 'select',
+        label: t('thinkingLabel'),
+        default: 'on',
+        options: THINKING_LEVELS.map(level => ({ label: level.label, value: level.id })),
+        description: t('thinkingDescription'),
     },
 });
 /**
@@ -246,10 +260,15 @@ class OllamaClient {
     keepAlive;
     logger;
     proc;
+    /**
+     * 生成请求的连接池：不设等响应头与读响应体的时限（默认各 300 秒），timeout 是唯一的时限。dispatcher 是 Node 自带 fetch
+     * 认的扩展字段，DOM 的 RequestInit 里没有（测试的类型检查带 DOM），带它的选项按 RequestInit 断言
+     */
+    dispatcher = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
     constructor(config, logger, proc) {
         this.baseUrl = config.baseUrl.replace(/\/$/, '');
-        // schema 中 timeout 单位为「秒」，存储为毫秒；0 视为不限制 → 用一个非常大的值
-        this.timeout = config.timeout && config.timeout > 0 ? config.timeout * 1000 : 2_147_483_647;
+        // schema 中 timeout 单位为「秒」，存储为毫秒；0 或负数不限，超过定时器上限按上限计，报错里的秒数是生效的值（见 idleTimeout）
+        this.timeout = Math.min(config.timeout * 1000, IDLE_TIMEOUT_MAX_MS);
         this.temperature = config.temperature;
         this.maxTokens = config.maxTokens;
         this.contextLength = config.contextLength;
@@ -257,24 +276,31 @@ class OllamaClient {
         this.logger = logger;
         this.proc = proc;
     }
+    /** 停用时关掉生成请求的连接池，之后的请求被拒（报插件已停用或重载）。不等在飞的请求读完：它们是调用方的，等它们会让重载卡到回复写完 */
+    close() {
+        void this.dispatcher.close();
+    }
     /** 对话请求的非 2xx 应答：截断后的响应体记 warn，抛出的错误见 httpErrorMessage */
     apiError(status, body) {
         this.logger.warn(`Ollama API 错误 (${status}): ${bodyExcerpt(body)}`);
-        return new Error(httpErrorMessage('Ollama', status, body));
+        return new TextError(httpErrorMessage('Ollama', status, body));
     }
     /**
-     * 对话请求没拿到完整应答（fetch 或读响应体时抛出）：原始错误连同原因记 warn，超时与连不上各换成一句说明，其它错误
-     * 原样返回。调用方经 request.signal 中止时原样返回、不记日志，agent 按中止收尾
+     * 对话请求没拿到完整应答（fetch 或读响应体时抛出）：原始错误连同原因记 warn，超时、连不上与连接池已关闭（插件停用或重载）
+     * 各换成一句说明，其它错误原样返回。调用方经 request.signal 中止时原样返回、不记日志，agent 按中止收尾
      */
     requestError(err, request, startedAt) {
         if (request.signal?.aborted)
             return err;
-        this.logger.warn(`Ollama 请求失败 (耗时 ${Date.now() - startedAt}ms): ${describeError(err)}`);
+        this.logger.warn(`Ollama 请求失败 (耗时 ${Date.now() - startedAt}ms): ${toSource(describeError(err))}`);
         if (err instanceof DOMException && err.name === 'TimeoutError') {
-            return new Error(`Ollama 请求超时：${this.timeout / 1000} 秒内没有完成，可在配置里调大 timeout`);
+            return new TextError(t('requestTimeout', { seconds: this.timeout / 1000 }));
         }
         if (err instanceof TypeError && err.message === 'fetch failed') {
-            return new Error('Ollama 连不上服务：检查 baseUrl 与网络，详情见日志');
+            if (err.cause instanceof errors.ClientClosedError || err.cause instanceof errors.ClientDestroyedError) {
+                return new TextError(t('pluginClosed'));
+            }
+            return new TextError(t('unreachable'));
         }
         return err;
     }
@@ -285,7 +311,7 @@ class OllamaClient {
         }
         catch {
             this.logger.warn(`Ollama 应答不是 JSON (${status}): ${bodyExcerpt(text)}`);
-            throw new Error(`Ollama 应答不是 JSON (${status})；详情见日志`);
+            throw new TextError(t('notJson', { status }));
         }
     }
     /**
@@ -312,17 +338,17 @@ class OllamaClient {
                 data = JSON.parse(text);
             }
             catch {
-                throw new Error(`响应不是 JSON: ${bodyExcerpt(text)}`);
+                throw new TextError(t('discoveryNotJson', { excerpt: bodyExcerpt(text) }));
             }
             const list = data?.models;
             if (!Array.isArray(list) || !list.every(m => typeof m?.name === 'string')) {
-                throw new Error(`响应不是模型列表（需要 models 数组，每项带字符串 name）: ${bodyExcerpt(JSON.stringify(data))}`);
+                throw new TextError(t('discoveryNotList', { excerpt: bodyExcerpt(JSON.stringify(data)) }));
             }
             return list.map(m => m.name);
         }
         catch (err) {
             signal?.throwIfAborted();
-            throw new Error(`模型发现失败 ${redactUrl(url)}: ${describeError(err)}`, { cause: err });
+            throw new TextError(t('discoveryFailed', { url, error: describeError(err) }), { cause: err });
         }
     }
     /**
@@ -350,9 +376,9 @@ class OllamaClient {
     /**
      * chat / chatStream 共用的 /api/chat 请求体（两侧只差 stream 标志；分开写曾让两侧漂移）。
      * 先走 prepareLLMMessages（归一 role + 拼 kind/自定义 role 内容前缀），否则丢
-     * [系统通知]/[跨会话委派] 等前缀。
+     * [系统通知]/[跨会话委派] 等前缀。level 是这次的思考档位，不能调的模型没有
      */
-    async buildRequestBody(model, request, defaultThinking, stream) {
+    async buildRequestBody(model, request, level, stream) {
         const messages = await Promise.all(prepareLLMMessages(request.messages).map(m => this.toOllamaMessage(m, request.requireImages === true)));
         const tools = request.tools?.map(t => this.toOllamaTool(t));
         const body = {
@@ -369,24 +395,18 @@ class OllamaClient {
         if (tools && tools.length > 0) {
             body.tools = tools;
         }
-        // 启用原生思考模式（Ollama API think 参数）
-        // 调用方可通过 request.think === false 显式关闭
-        // 必须显式传 think:false 才能关闭 gemma4:31b 等原生 thinking 模型的思考；
-        // 仅省略字段会被模型默认启用思考，导致 content 为空。
-        const shouldThink = request.think !== undefined ? request.think : defaultThinking;
-        body.think = shouldThink;
-        return { body, messages, tools, shouldThink };
+        // 能思考的模型总是明说 think：gemma4:31b 等原生思考模型省略字段会默认思考，content 可能为空。没有思考能力的模型不发
+        if (level !== undefined)
+            body.think = level === 'on';
+        return { body, messages, tools };
     }
-    async chat(model, request, defaultThinking) {
+    async chat(model, request, level) {
         // 包含音频输入 → 改走 OpenAI 兼容的 /v1/chat/completions（/api/chat 不支持 audios）
         if (request.messages.some(m => m.audios && m.audios.length > 0)) {
-            return this.chatOpenAIWithAudio(model, request);
+            return this.chatOpenAIWithAudio(model, request, level);
         }
-        const { body, messages, tools, shouldThink } = await this.buildRequestBody(model, request, defaultThinking, false);
-        this.logger.debug(`请求 Ollama${shouldThink ? ' [think]' : ''}: ${body.model}, ${messages.length} 条消息, ${tools?.length ?? 0} 个工具`);
-        const signals = [AbortSignal.timeout(this.timeout)];
-        if (request.signal)
-            signals.push(request.signal);
+        const { body, messages, tools } = await this.buildRequestBody(model, request, level, false);
+        this.logger.debug(`请求 Ollama${level ? ` (思考 ${level})` : ''}: ${body.model}, ${messages.length} 条消息, ${tools?.length ?? 0} 个工具`);
         const startedAt = Date.now();
         let response;
         let text;
@@ -395,7 +415,8 @@ class OllamaClient {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
-                signal: AbortSignal.any(signals),
+                signal: idleTimeout(this.timeout, request.signal).signal,
+                dispatcher: this.dispatcher,
             });
             text = await response.text();
         }
@@ -405,14 +426,15 @@ class OllamaClient {
         if (!response.ok)
             throw this.apiError(response.status, text);
         const data = this.parseJsonBody(response.status, text);
-        // 优先使用原生 thinking 字段（Ollama think API），回退到 <think> 标签解析
+        // 发了 think 时思考由 Ollama 管、走原生 thinking 字段，正文照原样；没发时才把正文里 <think> 标签之间的内容当思考
         const nativeThinking = data.message.thinking || '';
         const rawContent = data.message.content || '';
-        const { reasoning: tagReasoning, content: cleanContent } = extractThinkTags(rawContent);
+        const { reasoning: tagReasoning, content: cleanContent } = level === undefined ? extractThinkTags(rawContent) : { reasoning: '', content: rawContent };
         const allReasoning = [nativeThinking, tagReasoning].filter(Boolean).join('');
         const result = {
             content: cleanContent || null,
             reasoningContent: allReasoning || null,
+            finishReason: finishReasonOf(data.done_reason),
         };
         const toolCalls = finalizeToolCalls(data.message.tool_calls);
         if (toolCalls)
@@ -428,23 +450,34 @@ class OllamaClient {
         }
         return result;
     }
-    async *chatStream(model, request, defaultThinking) {
+    async *chatStream(model, request, level) {
         // 包含音频输入 → 回退为非流式（OpenAI compat 路径不支持 SSE 交互）后以单 chunk 交付。
         if (request.messages.some(m => m.audios && m.audios.length > 0)) {
-            const r = await this.chatOpenAIWithAudio(model, request);
+            const r = await this.chatOpenAIWithAudio(model, request, level);
             yield {
                 contentDelta: r.content ?? '',
                 reasoningDelta: r.reasoningContent ?? '',
                 usage: r.usage,
                 done: true,
+                finishReason: r.finishReason,
             };
             return;
         }
-        const { body, messages, shouldThink } = await this.buildRequestBody(model, request, defaultThinking, true);
-        this.logger.debug(`流式请求 Ollama${shouldThink ? ' [think]' : ''}: ${body.model}, ${messages.length} 条消息`);
-        const signals = [AbortSignal.timeout(this.timeout)];
-        if (request.signal)
-            signals.push(request.signal);
+        const { body, messages } = await this.buildRequestBody(model, request, level, true);
+        this.logger.debug(`流式请求 Ollama${level ? ` (思考 ${level})` : ''}: ${body.model}, ${messages.length} 条消息`);
+        // 交出一段期间不计时：调用方处理一段的时间不算停顿
+        const timer = idleTimeout(this.timeout, request.signal);
+        for await (const chunk of this.readStream(body, request, timer, level === undefined)) {
+            timer.pause();
+            yield chunk;
+            timer.resume();
+        }
+    }
+    /**
+     * 发出流式请求并逐段解析，timer 管这次请求的停顿超时。parseThinkTags 为真（这次没发 think）时把正文里 <think> 标签之间的
+     * 内容当思考交出，为假时正文照原样交出
+     */
+    async *readStream(body, request, timer, parseThinkTags) {
         const reqStart = Date.now();
         const slowConnectTimer = setTimeout(() => {
             this.logger.warn(`Ollama 连接慢：已等待 15s 仍未收到响应头 (url=${this.baseUrl}/api/chat)`);
@@ -455,7 +488,8 @@ class OllamaClient {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
-                signal: AbortSignal.any(signals),
+                signal: timer.signal,
+                dispatcher: this.dispatcher,
             });
         }
         catch (err) {
@@ -471,7 +505,7 @@ class OllamaClient {
             throw this.apiError(response.status, errorText);
         }
         if (!response.body) {
-            throw new Error('Ollama API 返回了空的响应体，无法进行流式读取');
+            throw new TextError(t('emptyBody'));
         }
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
@@ -506,6 +540,9 @@ class OllamaClient {
                         continue;
                     try {
                         const data = JSON.parse(trimmed);
+                        // 带生成内容的帧重新计时：正文（含按标签解析出的思考）、原生思考、工具调用
+                        if (data.message?.content || data.message?.thinking || data.message?.tool_calls?.length)
+                            timer.touch();
                         // 累积工具调用
                         if (data.message?.tool_calls) {
                             toolCallBuffers.push(...data.message.tool_calls);
@@ -532,7 +569,7 @@ class OllamaClient {
                                 tagBuffer = '';
                             }
                             // 最后一个 chunk
-                            const chunk = { done: true };
+                            const chunk = { done: true, finishReason: finishReasonOf(data.done_reason) };
                             const toolCalls = finalizeToolCalls(toolCallBuffers);
                             if (toolCalls)
                                 chunk.toolCalls = toolCalls;
@@ -548,11 +585,15 @@ class OllamaClient {
                             yield chunk;
                             return;
                         }
-                        // 原生 thinking 字段（Ollama think API）—— 优先级高于 <think> 标签解析
+                        // 原生 thinking 字段（Ollama think API）
                         if (data.message?.thinking) {
                             yield { reasoningDelta: data.message.thinking };
                         }
-                        if (data.message?.content) {
+                        // 发了 think：思考由 Ollama 管，正文照原样交出
+                        if (data.message?.content && !parseThinkTags) {
+                            yield { contentDelta: data.message.content };
+                        }
+                        else if (data.message?.content) {
                             // 解析 <think> / </think> 标签，将内部内容路由为 reasoningDelta
                             let text = tagBuffer + data.message.content;
                             tagBuffer = '';
@@ -626,7 +667,7 @@ class OllamaClient {
             clearTimeout(streamStallTimer);
             // cancel 而非仅 releaseLock：中止/提前退出时要主动关闭响应体。releaseLock 只是放锁，
             // 底层流仍开着——被打断的生成会让 undici 挂着半读的响应与套接字，直到请求超时兜底
-            // 才释放（本地慢生成 + lane 中止高频后，这类残留一挂就是整个超时窗）。
+            // 才释放（本地慢生成时回合常被停下，这类残留一挂就是整个超时窗）。
             // cancel 自带放锁。三条退出路径的语义：读尽 EOF（done:true）→ 流已 closed，cancel 是
             // 真 no-op；收到终帧即 return（未读到 EOF）与消费方提前 break → cancel 中止残余响应体，
             // 这正是本修复要的「立即交还套接字」，代价是该连接不回 keep-alive 池。
@@ -703,7 +744,7 @@ class OllamaClient {
         if (valid.length === images.length)
             return valid;
         if (valid.length === 0 && requireImages) {
-            throw new Error(`图片全部获取失败（共 ${images.length} 张），拒绝降级为纯文本请求`);
+            throw new TextError(t('imagesUnavailable', { count: images.length }));
         }
         this.logger.warn(`图片获取失败 ${images.length - valid.length}/${images.length} 张，按剩余的继续`);
         return valid;
@@ -756,7 +797,7 @@ class OllamaClient {
      * audios 字段时，/api/chat 原生路径不支持，必须走这里。
      * 文本与工具调用等其它能力仍由 chat() 走原生路径。
      */
-    async chatOpenAIWithAudio(model, request) {
+    async chatOpenAIWithAudio(model, request, level) {
         // 将 Aalis Message 转为 OpenAI multimodal content blocks
         const oaiMessages = await Promise.all(prepareLLMMessages(request.messages).map(async (m) => {
             const role = toLLMRole(m.role);
@@ -788,12 +829,10 @@ class OllamaClient {
             max_tokens: request.maxTokens ?? this.maxTokens,
             temperature: request.temperature ?? this.temperature,
         };
-        // Ollama 0.20+ thinking 控制：OpenAI 兼容路径只认 reasoning_effort，
-        // 不认 /api/chat 的 think 字段。think=false → reasoning_effort: "none"
-        // 节省 ~5-8x completion tokens（实测 935 → 155）。
-        if (request.think === false) {
+        // Ollama 0.20+ 的兼容路径只认 reasoning_effort、不认 /api/chat 的 think：关 → reasoning_effort: "none"，
+        // 节省 ~5-8x completion tokens（实测 935 → 155）；开按模型默认，不发
+        if (level === 'off')
             body.reasoning_effort = 'none';
-        }
         this.logger.debug(`请求 Ollama (OpenAI compat, audio): ${model}, ${oaiMessages.length} 条消息`);
         // 统计本次发送的音频载荷大小，便于诊断模型是否真的收到了音频
         let totalAudioBytes = 0;
@@ -812,9 +851,6 @@ class OllamaClient {
         if (audioCount > 0) {
             this.logger.info(`[ollama-audio] 发送 ${audioCount} 段音频，合计 ${(totalAudioBytes / 1024).toFixed(1)}KB`);
         }
-        const signals = [AbortSignal.timeout(this.timeout)];
-        if (request.signal)
-            signals.push(request.signal);
         const httpT0 = Date.now();
         let resp;
         let respText;
@@ -823,7 +859,8 @@ class OllamaClient {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
-                signal: AbortSignal.any(signals),
+                signal: idleTimeout(this.timeout, request.signal).signal,
+                dispatcher: this.dispatcher,
             });
             respText = await resp.text();
         }
@@ -832,30 +869,25 @@ class OllamaClient {
         }
         if (!resp.ok) {
             this.logger.warn(`[ollama-audio] HTTP ${resp.status} 失败 ${Date.now() - httpT0}ms: ${bodyExcerpt(respText)}`);
-            const message = httpErrorMessage('Ollama', resp.status, respText);
-            // 诊断提示：ollama runner 把 input_audio 当 image 解码失败时报 "image: unknown format"，
-            // 99% 是模型本身不支持 audio modality（如 Nemotron-3 是纯文本/纯推理，
-            // 多模态版 Nemotron-Nano-VL 也只有 vision）。提示用户换 gemma3n / qwen2.5-omni
-            // 等明确支持 audio 的多模态模型。
-            const lowerErr = respText.toLowerCase();
-            if (lowerErr.includes('image: unknown format') || lowerErr.includes('unknown format')) {
-                throw new Error(`${message}\n` +
-                    `[诊断] 模型 "${model}" 很可能不支持 audio modality（ollama runner 把 input_audio 当 image 解码失败）。` +
-                    `请改用明确支持音频的模型（如 gemma3n、qwen2.5-omni）。`);
-            }
-            throw new Error(message);
+            throw new TextError(httpErrorMessage('Ollama', resp.status, respText));
         }
         const data = this.parseJsonBody(resp.status, respText);
         const rawContent = data.choices?.[0]?.message?.content ?? '';
-        const finishReason = data.choices?.[0]?.finish_reason ?? '?';
-        const text = rawContent.trim();
+        const finishReason = data.choices?.[0]?.finish_reason;
+        // 与 /api/chat 同一条规则：这次没管思考（level 为 undefined）时才把正文里 <think> 标签之间的内容当思考
+        const { reasoning, content } = level === undefined ? extractThinkTags(rawContent) : { reasoning: '', content: rawContent };
+        const text = content.trim();
         if (audioCount > 0) {
-            this.logger.info(`[ollama-audio] ${model} HTTP ${Date.now() - httpT0}ms, finish=${finishReason}, ` +
+            this.logger.info(`[ollama-audio] ${model} HTTP ${Date.now() - httpT0}ms, finish=${finishReason ?? '?'}, ` +
                 `raw=${rawContent.length}字 trim=${text.length}字, ` +
                 `tokens prompt=${data.usage?.prompt_tokens ?? '?'} completion=${data.usage?.completion_tokens ?? '?'}` +
                 (rawContent.length > 0 ? `, 原文="${rawContent.replace(/\n/g, ' ')}"` : ' [模型返回空字符串]'));
         }
-        const result = { content: text || null, reasoningContent: null };
+        const result = {
+            content: text || null,
+            reasoningContent: reasoning || null,
+            finishReason: finishReasonOf(finishReason),
+        };
         if (data.usage) {
             result.usage = {
                 promptTokens: data.usage.prompt_tokens ?? 0,
@@ -866,32 +898,30 @@ class OllamaClient {
         return result;
     }
 }
-/** 去掉 base64 音频的 data: 前缀，返回纯 payload。 */
-function stripAudioDataPrefix(s) {
-    const m = s.match(/^data:[^;]+;base64,(.+)$/);
-    return m ? m[1] : s;
-}
 /**
- * 将 Aalis 传过来的 audio payload（可能带 data: 前缀也可能不带）解析为
- * OpenAI input_audio 需要的 `{ data, format }`。format 推断优先级：
- * data URL 的 mime 后缀 → 默认 wav。
+ * data URL 的音频类型（audio/ 之后的部分）→ OpenAI 兼容接口 input_audio 的 format。只收 wav 与 mp3：Ollama 的兼容接口不看
+ * format、只把 data 按 base64 解码（ollama 仓的 openai/openai.go），之后按文件头认音频，只认 wav 与 mp3（llm/media.go 的
+ * AudioFormat；mlxrunner/model/audio/audio.go 的 Decode 只认 wav）
+ */
+const AUDIO_FORMATS = new Map([
+    ['mpeg', 'mp3'],
+    ['mp3', 'mp3'],
+    ['wav', 'wav'],
+    ['x-wav', 'wav'],
+    ['wave', 'wav'],
+]);
+/**
+ * 把 `data:audio/<类型>[;参数];base64,…` 解析为 OpenAI input_audio 需要的 `{ data, format }`。format 只按写明的类型映射；
+ * 认不出的类型与不是 data URL 的（本地路径、链接、裸 base64）在发请求前报错：猜成 wav 时上游只回一句解码失败，看不出是格式的事
  */
 function decodeAudioForOpenAI(payload) {
-    const m = payload.match(/^data:audio\/([^;]+);base64,(.+)$/);
-    if (m) {
-        const fmt = m[1].toLowerCase();
-        const norm = fmt === 'mpeg' || fmt === 'mp3'
-            ? 'mp3'
-            : fmt === 'x-wav' || fmt === 'wave' || fmt === 'wav'
-                ? 'wav'
-                : fmt === 'ogg' || fmt === 'oga' || fmt === 'opus'
-                    ? 'ogg'
-                    : fmt === 'm4a' || fmt === 'mp4' || fmt === 'aac'
-                        ? 'm4a'
-                        : 'wav';
-        return { data: m[2], format: norm };
-    }
-    return { data: stripAudioDataPrefix(payload), format: 'wav' };
+    const m = payload.match(/^data:audio\/([^;,]+)(?:;[^;,]+)*;base64,(.+)$/);
+    if (!m)
+        throw new TextError(t('audioDataUrlOnly'));
+    const format = AUDIO_FORMATS.get(m[1].toLowerCase());
+    if (!format)
+        throw new TextError(t('audioFormatUnsupported', { format: m[1] }));
+    return { data: m[2], format };
 }
 function safeParseJSON(str) {
     try {
@@ -903,6 +933,8 @@ function safeParseJSON(str) {
 }
 // ===== 模型能力映射 =====
 const { Chat, ToolCalling, Streaming, Vision, Audio, Thinking } = LLMCapabilities;
+// 能力探测（/api/show）失败时的回退。前缀匹配按表序取第一个命中，更具体的前缀排在更短的之前（qwen3-coder 在 qwen3 之前）。
+// 原生思考的族标 Thinking：探测失败时照样声明档位、明说 think，省略字段它们会默认思考
 const MODEL_CAPABILITIES = {
     'llama3.1': [Chat, ToolCalling, Streaming],
     'llama3.2': [Chat, ToolCalling, Streaming],
@@ -911,12 +943,13 @@ const MODEL_CAPABILITIES = {
     'llava-llama3': [Chat, Streaming, Vision],
     gemma2: [Chat, Streaming],
     gemma3: [Chat, ToolCalling, Streaming, Vision],
-    gemma4: [Chat, ToolCalling, Streaming, Vision],
+    gemma4: [Chat, ToolCalling, Streaming, Vision, Thinking],
     'qwen2.5': [Chat, ToolCalling, Streaming],
     'qwen2.5-coder': [Chat, ToolCalling, Streaming],
-    qwen3: [Chat, ToolCalling, Streaming],
+    'qwen3-coder': [Chat, ToolCalling, Streaming],
+    qwen3: [Chat, ToolCalling, Streaming, Thinking],
     mistral: [Chat, ToolCalling, Streaming],
-    'deepseek-r1': [Chat, Streaming],
+    'deepseek-r1': [Chat, Streaming, Thinking],
     phi4: [Chat, Streaming],
     'command-r': [Chat, ToolCalling, Streaming],
 };
@@ -1053,12 +1086,14 @@ class OllamaModelHandle {
     providerId;
     contextLength;
     maxOutputTokens;
-    defaultThinking;
     capabilities;
+    thinking;
     refresh;
-    constructor(client, id, providerId, contextLength, maxOutputTokens, defaultThinking, 
+    constructor(client, id, providerId, contextLength, maxOutputTokens, 
     /** 该 model 的能力元数据（供 media 发现/下拉展示读取，非 DI 选择机制）。 */
     capabilities, 
+    /** 能思考的模型才有：默认档取实例配置 */
+    thinking, 
     /** Provider 级共享的 refresh 闭包；webui 按 providerId 找到该 provider 的任一 entry 调一次即可。关闭模型发现时没有 */
     refresh) {
         this.client = client;
@@ -1066,18 +1101,22 @@ class OllamaModelHandle {
         this.providerId = providerId;
         this.contextLength = contextLength;
         this.maxOutputTokens = maxOutputTokens;
-        this.defaultThinking = defaultThinking;
         this.capabilities = capabilities;
+        this.thinking = thinking;
         this.refresh = refresh;
     }
-    chat(request) {
-        return this.client.chat(this.id, request, this.defaultThinking);
+    async chat(request) {
+        return this.client.chat(this.id, request, this.levelOf(request));
+    }
+    async *chatStream(request) {
+        yield* this.client.chatStream(this.id, request, this.levelOf(request));
     }
-    chatStream(request) {
-        return this.client.chatStream(this.id, request, this.defaultThinking);
+    /** 这次的档位：请求带了按请求，没带按默认档；不能调的模型没有 */
+    levelOf(request) {
+        return requestedThinking(this, request) ?? this.thinking?.default;
     }
 }
-const uses = { config, logger, lifecycle, provide, proc: optional(processService) };
+const uses = { config, logger, lifecycle, provide, events, proc: optional(processService) };
 export default definePlugin({
     name: '@aalis/plugin-llm-ollama',
     displayName: 'Ollama',
@@ -1088,18 +1127,18 @@ export default definePlugin({
     uses,
     apply: start,
 });
-async function start({ config, logger, lifecycle, provide, proc }) {
-    const cfg = parseConfig(configSchema, config, logger);
+async function start({ config, logger, lifecycle, provide, events, proc }) {
+    const cfg = parseConfig(configSchema, config.use, logger.use);
     const customModels = parseCustomModels(cfg.customModels);
     const modelCapabilities = parseModelCapabilities(cfg.modelCapabilities);
     const providerCapabilities = parseProviderCapabilities(cfg.providerCapabilities);
     checkBaseUrl(cfg.baseUrl);
     if (!cfg.discoverModels && customModels.length === 0) {
-        throw missingConfigError('customModels', '关闭 discoverModels 时必填');
+        throw missingConfigError('customModels', t('customModelsRequired'));
     }
-    const client = new OllamaClient(cfg, logger, createProcessGateway(proc));
+    const client = new OllamaClient(cfg, logger.use, proc.use);
+    lifecycle.use.onDispose(() => client.close(), '关闭生成请求的连接池');
     const baseLabel = `Ollama (${cfg.baseUrl.replace(/^https?:\/\//, '')})`;
-    const shownBaseUrl = redactUrl(cfg.baseUrl);
     // 已注册 model entry 的句柄表：modelId → 该 entry 的退订
     const registered = new Map();
     // 同 provider 下所有 OllamaModelHandle 共享同一份 refresh。关闭模型发现时不提供：没有可重新发现的列表
@@ -1110,13 +1149,13 @@ async function start({ config, logger, lifecycle, provide, proc }) {
             return false;
         const capabilities = resolveCapabilities(modelId, modelCapabilities.get(modelId), providerCapabilities, detected);
         if (capabilities.length === 0) {
-            logger.debug(`跳过 model entry "${modelId}": /api/show 未报告对话能力(embedding 等非对话模型)`);
+            logger.use.debug(`跳过 model entry "${modelId}": /api/show 未报告对话能力(embedding 等非对话模型)`);
             return false;
         }
-        const handle = new OllamaModelHandle(client, modelId, lifecycle.id, cfg.contextLength, cfg.maxTokens, cfg.thinking, capabilities, refresh);
-        const dispose = provide(llm, handle, {
+        const handle = new OllamaModelHandle(client, modelId, lifecycle.use.id, cfg.contextLength, cfg.maxTokens, capabilities, capabilities.includes(Thinking) ? { levels: THINKING_LEVELS, default: cfg.thinking } : undefined, refresh);
+        const dispose = provide.use(llm, metered(handle, events.use), {
             label: `${baseLabel} / ${modelId}`,
-            entryId: `${lifecycle.id}/${modelId}`,
+            entryId: `${lifecycle.use.id}/${modelId}`,
         });
         registered.set(modelId, dispose);
         return true;
@@ -1129,7 +1168,7 @@ async function start({ config, logger, lifecycle, provide, proc }) {
             d();
         }
         catch (err) {
-            logger.warn(`卸载 model entry "${modelId}" 失败: ${err}`);
+            logger.use.warn(`卸载 model entry "${modelId}" 失败: ${err}`);
         }
         registered.delete(modelId);
     }
@@ -1138,7 +1177,7 @@ async function start({ config, logger, lifecycle, provide, proc }) {
         const remoteSet = new Set(remoteIds);
         for (const cm of customModels) {
             if (remoteSet.has(cm)) {
-                logger.warn(`自定义模型 "${cm}" 与自动发现的模型重复，请在配置中去重`);
+                logger.use.warn(`自定义模型 "${cm}" 与自动发现的模型重复，请在配置中去重`);
             }
         }
         return [...remoteIds, ...customModels.filter(id => !remoteSet.has(id))];
@@ -1148,51 +1187,51 @@ async function start({ config, logger, lifecycle, provide, proc }) {
     // 发现失败只留消息：消息里已带 URL 与原因（cause 也内联在内），err 交给 logger 会按因果链把原因再记一遍
     let discoveryError;
     const remoteIds = cfg.discoverModels
-        ? await client.fetchRemoteModelIds(lifecycle.signal).catch((err) => {
-            discoveryError = err instanceof Error ? err.message : String(err);
+        ? await client.fetchRemoteModelIds(lifecycle.use.signal).catch((err) => {
+            discoveryError = textOf(err);
             return [];
         })
         : [];
-    lifecycle.signal.throwIfAborted();
+    lifecycle.use.signal.throwIfAborted();
     const initialIds = withCustomModels(remoteIds);
     // 一个模型都没有时抛配置错误，原因成为实例的错误信息；否则只剩 core 的「声明 provides [llm] 但未实际注册」。
     // 提示写在原因之前：原因里可能带着一段响应体
     if (initialIds.length === 0) {
         throw configError(discoveryError
-            ? `未配置 customModels，没有可注册的模型；${discoveryError}`
-            : `Ollama 已连接 ${shownBaseUrl}，但未发现任何可用模型；先用 ollama pull 下载模型，或在 customModels 里写明要用的模型`);
+            ? t('noModelsDiscoveryFailed', { error: discoveryError })
+            : t('noModels', { baseUrl: cfg.baseUrl }));
     }
     if (discoveryError)
-        logger.warn(`启动时只注册 customModels 里的模型；${discoveryError}`);
+        logger.use.warn(`启动时只注册 customModels 里的模型；${toSource(discoveryError)}`);
     // 并行查每个模型的真实能力(顺序保留→注册顺序稳定→优先级稳定);失败者回退家族表。
-    const detectedCaps = await Promise.all(initialIds.map(id => client.fetchModelCapabilities(id, lifecycle.signal)));
-    lifecycle.signal.throwIfAborted();
+    const detectedCaps = await Promise.all(initialIds.map(id => client.fetchModelCapabilities(id, lifecycle.use.signal)));
+    lifecycle.use.signal.throwIfAborted();
     for (let i = 0; i < initialIds.length; i++)
         registerOne(initialIds[i], detectedCaps[i]);
     // 模型都被当作非对话模型跳过（如只装了嵌入模型）时同样抛配置错误。只有 /api/show 答复过才会跳过，所以是已连接
     if (registered.size === 0) {
-        throw configError(`Ollama 已连接 ${shownBaseUrl}，但没有可用的对话模型：${initialIds.join(', ')} 都没有报告对话能力（如嵌入模型）；先用 ollama pull 下载对话模型`);
+        throw configError(t('noChatModels', { baseUrl: cfg.baseUrl, models: initialIds.join(', ') }));
     }
-    logger.info(!cfg.discoverModels
-        ? `Ollama 未开启模型发现: ${shownBaseUrl}，注册 customModels 里的 ${registered.size} 个 model entry`
+    logger.use.info(!cfg.discoverModels
+        ? `Ollama 未开启模型发现: ${cfg.baseUrl}，注册 customModels 里的 ${registered.size} 个 model entry`
         : discoveryError
-            ? `Ollama 模型发现失败: ${shownBaseUrl}，注册 customModels 里的 ${registered.size} 个 model entry`
-            : `Ollama 已连接: ${shownBaseUrl}，注册 ${registered.size} 个 model entry`);
+            ? `Ollama 模型发现失败: ${cfg.baseUrl}，注册 customModels 里的 ${registered.size} 个 model entry`
+            : `Ollama 已连接: ${cfg.baseUrl}，注册 ${registered.size} 个 model entry`);
     /**
      * 重新发现并按差异增删条目（WebUI 触发，无需重启插件）。与初次注册一样随停用或停机中止：每次 await 之后自己查，
      * 中止即抛出，不再增删条目。模型发现失败同样抛出（WebUI 据此报错）、不增删条目：按空列表处理会把自动发现的
      * 条目全部注销
      */
     async function refreshModels() {
-        const next = withCustomModels(await client.fetchRemoteModelIds(lifecycle.signal));
-        lifecycle.signal.throwIfAborted();
+        const next = withCustomModels(await client.fetchRemoteModelIds(lifecycle.use.signal));
+        lifecycle.use.signal.throwIfAborted();
         const nextSet = new Set(next);
         const added = [];
         const removed = [];
         // 新模型的能力并行探测（与初次注册一致），再按发现顺序登记
         const fresh = next.filter(id => !registered.has(id));
-        const detectedCaps = await Promise.all(fresh.map(id => client.fetchModelCapabilities(id, lifecycle.signal)));
-        lifecycle.signal.throwIfAborted();
+        const detectedCaps = await Promise.all(fresh.map(id => client.fetchModelCapabilities(id, lifecycle.use.signal)));
+        lifecycle.use.signal.throwIfAborted();
         for (let i = 0; i < fresh.length; i++) {
             // 非对话模型被跳过、等能力探测期间并发的刷新已登记，都不算本次新增
             if (registerOne(fresh[i], detectedCaps[i]))
@@ -1205,10 +1244,10 @@ async function start({ config, logger, lifecycle, provide, proc }) {
             }
         }
         if (added.length || removed.length) {
-            logger.info(`Ollama 模型列表已刷新: +${added.length} (${added.join(',') || '-'}) / -${removed.length} (${removed.join(',') || '-'}) / 现共 ${registered.size}`);
+            logger.use.info(`Ollama 模型列表已刷新: +${added.length} (${added.join(',') || '-'}) / -${removed.length} (${removed.join(',') || '-'}) / 现共 ${registered.size}`);
         }
         else {
-            logger.debug(`Ollama 模型列表已刷新: 无变化 (共 ${registered.size})`);
+            logger.use.debug(`Ollama 模型列表已刷新: 无变化 (共 ${registered.size})`);
         }
         return { added, removed, total: registered.size };
     }